//-----------------------------------------------------------------------------
// Copyright (C) David Welch, 2000, 2003
//-----------------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <termios.h>

#include <unistd.h>

#include "ser.h"

FILE *dat;

struct termios oldsettings;

unsigned char data[4096];

//DONT USE
unsigned char sdata[2048]; //dont use
unsigned char rdata[8192]; //dont use
unsigned short records;
unsigned short count;


FILE *fp;

unsigned long errors;

unsigned long addhigh;
unsigned long add;

unsigned long ra;
unsigned long rb;

unsigned long pages;
unsigned long page;

unsigned long line;

unsigned char checksum;


unsigned long len;
unsigned long maxadd;

unsigned char gstring[80];
unsigned char newline[1024];

unsigned char memory[600*1024];

unsigned char t;




//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int readhex ( void )
{

    memset(memory,0xFF,sizeof(memory));
    maxadd=0;


    line=0;
    while(fgets(newline,sizeof(newline)-1,fp))
    {
        line++;
        if(newline[0]!=':')
        {
            printf("Syntax error <%lu> no colon\n",line);
            continue;
        }
        gstring[0]=newline[1];
        gstring[1]=newline[2];
        gstring[2]=0;

        len=strtoul(gstring,NULL,16);
        checksum=0;
        for(ra=0;ra<(len+5);ra++)
        {
            gstring[0]=newline[(ra<<1)+1];
            gstring[1]=newline[(ra<<1)+2];
            gstring[2]=0;
            checksum+=(unsigned char)strtoul(gstring,NULL,16);
        }
        if(checksum)
        {
            printf("checksum error <%lu>\n",line);
        }
        gstring[0]=newline[3];
        gstring[1]=newline[4];
        gstring[2]=newline[5];
        gstring[3]=newline[6];
        gstring[4]=0;
        add=strtoul(gstring,NULL,16);
        add|=addhigh;


        if(add>0x80000)
        {
            printf("address too big\n");
            exit(1);
        }

        gstring[0]=newline[7];
        gstring[1]=newline[8];
        gstring[2]=0;
        t=(unsigned char)strtoul(gstring,NULL,16);

        //;llaaaattdddddd
        //01234567890

        switch(t)
        {
            default:
                printf("UNKOWN type %02X <%lu>\n",t,line);
                break;
            case 0x00:
                for(ra=0;ra<len;ra++)
                {

                    if(add>maxadd) maxadd=add;

                    gstring[0]=newline[(ra<<1)+9];
                    gstring[1]=newline[(ra<<1)+10];
                    gstring[2]=0;

                    memory[add]=(unsigned char)strtoul(gstring,NULL,16);
//                    printf("%08lX: %02X\n",add,t);
                    add++;

                }
                break;
            case 0x01:
                printf("End of data\n");
                break;
            case 0x02:
                gstring[0]=newline[9];
                gstring[1]=newline[10];
                gstring[2]=newline[11];
                gstring[3]=newline[12];
                gstring[4]=0;
                addhigh=strtoul(gstring,NULL,16);
                addhigh<<=16;
                printf("addhigh %08lX\n",addhigh);
                break;

        }
    }

    printf("%lu lines processed\n",line);
    printf("%08lX\n",maxadd);

    if(maxadd&0x7F)
    {
        maxadd+=0x80;
        maxadd&=0xFFFFFF80;
        printf("%08lX\n",maxadd);
    }

    return(0);


}


//-----------------------------------------------------------------------------
void showstring ( unsigned short x)
{
    int i;
    for(i=0;i<x;i++)
    {
        printf("[%02X]",data[i]);
        if((data[i]>0x20)&&(data[i]<127)) printf("%c",data[i]);
    }
    printf("\n");
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
int main ( int argc, char *argv[] )
{
  struct termios newsettings;

    if(argc<2)
    {
        printf(".hex file not specified\n");
        return(1);
    }
    fp=fopen(argv[1],"rt");
    if(fp==NULL)
    {
        printf("error opening file %s\n",argv[1]);
        return(1);
    }
    if(readhex()) return(1);
    fclose(fp);


    pages=maxadd>>7;


  if(ser_open())
  {
    printf("ser_open() failed\n");
    return(1);
  }


  tcgetattr(0,&oldsettings);
  newsettings=oldsettings;
  newsettings.c_lflag&=(~ECHO);
  newsettings.c_lflag&=(~ICANON);
  newsettings.c_cc[VTIME]=0;
  newsettings.c_cc[VMIN]=0;
  tcsetattr(0,TCSANOW,&newsettings);

  printf("port opened\n");

    sdata[0]=0x1B;
    sdata[1]='S';
    ser_senddata(sdata,2);
    sleep(1);
    rb=ser_copystring(data); ser_dump(rb);
    showstring(rb);
    if(rb!=7)
    {
        printf("Sorry\n");
        return(1);
    }
    data[rb]=0;
    if(strcmp(data,"AVRBOOT")!=0)
    {
        printf("Sorry\n");
    }

    sdata[0]='t';
    ser_senddata(sdata,1);
    while(1)
    {
        rb=ser_copystring(data);
        if(rb==2) break;
    }
    ser_dump(rb);
    showstring(rb);

    sdata[0]='T';
    sdata[1]=data[0];
    ser_senddata(sdata,2);
    while(1)
    {
        rb=ser_copystring(data);
        if(rb==1) break;
    }
    showstring(rb);
    ser_dump(rb);

    printf("Erasing\n");

    sdata[0]='e';
    ser_senddata(sdata,1);
    while(1)
    {
        rb=ser_copystring(data);
        if(rb==1) break;
    }
    showstring(rb);
    ser_dump(rb);



    printf("Loading\n");

    line=0;

    sdata[0]='A';
    sdata[1]=0;
    sdata[2]=0;
    ser_senddata(sdata,3);
    while(1)
    {
        rb=ser_copystring(data);
        if(rb==1) break;
    }
    showstring(rb);
    ser_dump(rb);

    for(page=0;page<pages;page++)
    {
        sdata[0]='B';
        sdata[1]=0x00;
        sdata[2]=0x80;
        sdata[3]='F';
        ser_senddata(sdata,4);
        for(ra=0;ra<128;ra++) sdata[ra]=memory[line++];
        ser_senddata(sdata,128);
        while(1)
        {
            rb=ser_copystring(data);
            if(rb) break;
        }
        showstring(rb);
        ser_dump(rb);

    }

    printf("verify\n");
    line=0;
    errors=0;

    sdata[0]='A';
    sdata[1]=0;
    sdata[2]=0;
    ser_senddata(sdata,3);
    while(1)
    {
        rb=ser_copystring(data);
        if(rb) break;
    }
    showstring(rb);
    ser_dump(rb);

    for(page=0;page<pages;page++)
    {
        sdata[0]='g';
        sdata[1]=0x00;
        sdata[2]=0x80;
        sdata[3]='F';
        ser_senddata(sdata,4);
        while(1)
        {
            rb=ser_copystring(data);
            if(rb==128) break;
        }
        ser_dump(rb);
        for(ra=0;ra<128;ra++)
        {
            if(data[ra]!=memory[line])
            {
                printf("verify error %08lX %02X %02X\n",line,data[ra],memory[line]);
                errors++;
            }
            line++;
        }

    }


    printf("%lu verify errors\n",errors);

    sdata[0]='E';
    ser_senddata(sdata,1);



  tcsetattr(0,TCSANOW,&oldsettings);

  ser_close();
  printf("\n\n");
  return(0);
}
//-----------------------------------------------------------------------------
// Copyright (C) David Welch, 2000
//-----------------------------------------------------------------------------