Subversion Repositories pentevo

Rev

Rev 146 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed | ?url?

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <time.h>
  5.  
  6. typedef unsigned char BYTE;
  7. typedef unsigned short WORD;
  8. typedef unsigned long LONGWORD;
  9.  
  10. #define HEXLEN 0
  11. #define DATATYPE 1
  12. #define CHECKSUM 2
  13.  
  14. BYTE      checksum;
  15. WORD      col, row;
  16. LONGWORD  err;
  17. BYTE      s[256], s1[256];
  18.  
  19. //-----------------------------------------------------------------------------
  20.  
  21. BYTE toupper(BYTE b)
  22. {
  23.  if ( (b>0x61) && (b<0x7b) )  b&=0xdf;
  24.  return b;
  25. }
  26.  
  27. //-----------------------------------------------------------------------------
  28.  
  29. void print_err_rc()
  30. {
  31.  printf("Error! (Row %d, Col %d)\n",row,col+1);
  32.  err++;
  33. }
  34.  
  35. //-----------------------------------------------------------------------------
  36.  
  37. void print_err_r(BYTE cause)
  38. {
  39.  BYTE* cause_str[3]={"Number of byte","Unknown datatype","Checksum"};
  40.  printf("Error! %s. (Row %d)\n",cause_str[cause],row);
  41.  err++;
  42. }
  43.  
  44. //-----------------------------------------------------------------------------
  45.  
  46. BYTE getbyte()
  47. {
  48.  BYTE  b1, b0;
  49.  
  50.  b1=s[col];
  51.  if ( ( (b1>=0x30)&&(b1<=0x39) )||( (b1>=0x41)&&(b1<=0x46) ) )
  52.  {
  53.   b1-=0x30;
  54.   if (b1>9) b1-=7;
  55.  }
  56.  else
  57.  {
  58.   print_err_rc();
  59.   b1=0;
  60.  }
  61.  col++;
  62.  
  63.  b0=s[col];
  64.  if ( ( (b0>=0x30)&&(b0<=0x39) )||( (b0>=0x41)&&(b0<=0x46) ) )
  65.  {
  66.   b0-=0x30;
  67.   if (b0>9) b0-=7;
  68.  }
  69.  else
  70.  {
  71.   print_err_rc();
  72.   b0=0;
  73.  }
  74.  col++;
  75.  
  76.  b0|=(b1<<4);
  77.  checksum+=b0;
  78.  return b0;
  79. }
  80.  
  81. //-----------------------------------------------------------------------------
  82.  
  83. int main(int argc,char*argv[])
  84. {
  85.  BYTE       h[]="0123456789ABCDEF";
  86.  BYTE       b, m, o, hexlen, datatype;
  87.  WORD       i, ih, crc;
  88.  LONGWORD   x0, x1, adr, segadr;
  89.  struct tm  stm;
  90.  BYTE       vs[57]; //58-1
  91.  WORD       tabcrc[256];
  92.  BYTE       buff[0x1e000];
  93.  BYTE       header[0x80];
  94.  FILE*      f;
  95.  
  96.  printf("ZX EVO project:  HEX to BIN + CRC + Header\n");
  97.  if (argc<3) { printf("usage: MAKE_FW <HexFileName> <VersionFileName>\n"); return 2; }
  98.  
  99.  header[0]='Z';
  100.  header[1]='X';
  101.  header[2]='E';
  102.  header[3]='V';
  103.  header[4]='O';
  104.  header[5]=0x1a;
  105.  for (ih=0x06; ih<0x80; ih++) header[ih]=0;
  106.  ih=6;
  107.  o=0;
  108.  if (argc==4)
  109.   {
  110.    strncpy(s1,argv[3],1);
  111.    if (s1[0]=='o') o=0x80;
  112.   }
  113.  
  114.  strncpy(s1,argv[2],255);
  115.  f=fopen(s1,"rt");
  116.  vs[0]=0;
  117.  if (f)
  118.   {
  119.    fgets(vs,56,f);
  120.    fclose(f);
  121.   }
  122.  i=strlen(vs);
  123.  if ((i) && (vs[i-1]=='\n')) vs[--i]=0;
  124.  if (!i)
  125.   {
  126.    strcpy(vs, "No info");
  127.    o=0;
  128.   }
  129.  
  130.  strcpy(&header[ih], vs);
  131.  ih=strlen(header);
  132.  
  133.  strncpy(s1,argv[1],255);
  134.  f=fopen(s1,"rt");
  135.  if (!f) { printf("Can't open file %s!\n",s1); return 1; }
  136.  
  137.  for (adr=0;adr<0x1e000;adr++) buff[adr]=0xff;
  138.  err=0;
  139.  segadr=0;
  140.  row=0;
  141.  while (!feof(f))
  142.  {
  143.   row++;
  144.   col=0;
  145.   if (fgets(s,255,f) && strlen(s))
  146.   {
  147.    if (s[col]!=':') print_err_rc();
  148.    col++;
  149.    checksum=0;
  150.    hexlen=getbyte();
  151.    x1=getbyte();
  152.    x0=getbyte();
  153.    adr=segadr|(x1<<8)|x0;
  154.    datatype=getbyte();
  155.    switch (datatype)
  156.    {
  157.     // Data record
  158.     case 0: while (hexlen>0)
  159.             {
  160.              b=getbyte();
  161.              hexlen--;
  162.              if (adr<0x1e000) buff[adr]=b;
  163.              adr++;
  164.             }
  165.             break;
  166.     // End of file record
  167.     case 1: if (hexlen!=0) print_err_r(HEXLEN);
  168.             break;
  169.     // Extended segment address record
  170.     case 2: x1=getbyte();
  171.             x0=getbyte();
  172.             segadr=(x1<<12)|(x0<<4);
  173.             if (hexlen!=2) print_err_r(HEXLEN);
  174.             break;
  175.     // Start segment address record
  176.     case 3: break;
  177.     // Extended linear address record
  178.     case 4: x1=getbyte();
  179.             x0=getbyte();
  180.             segadr=(x1<<24)|(x0<<16);
  181.             if (hexlen!=2) print_err_r(HEXLEN);
  182.             break;
  183.     // Start linear address record
  184.     case 5: break;
  185.     default: print_err_r(DATATYPE);
  186.              while (hexlen!=0) { getbyte(); hexlen--; }
  187.    }
  188.    getbyte();
  189.    if (checksum!=0) print_err_r(CHECKSUM);
  190.   }
  191.  }
  192.  fclose(f);
  193.  
  194.  if (err) { printf("Total %d error(s)!\n",err); return 3; }
  195.  
  196.  
  197.  // comments place
  198.  {
  199.   time_t tt;
  200.   tt=time(NULL);
  201.   memcpy(&stm,localtime(&tt),sizeof(stm));
  202.  }
  203.  i=(WORD)(((stm.tm_year-100)&0x3f)<<9) | (((stm.tm_mon+1)&0x0f)<<5) | (stm.tm_mday&0x1f);
  204.  header[0x003e]=buff[0x1dffc]=(i>>8)&0x7f|o;
  205.  header[0x003f]=buff[0x1dffd]=i&0xff;
  206.  
  207.  strncpy(&buff[0x1dff0], vs, 12);
  208.  
  209.  for (i=0;i<256;i++)
  210.  {
  211.   crc=i<<8;
  212.   b=8;
  213.   do
  214.   {
  215.    if (crc&0x8000)
  216.     crc=(crc<<1)^0x1021;
  217.    else
  218.     crc<<=1;
  219.    b--;
  220.   }
  221.   while ((b)&&(crc));
  222.   tabcrc[i]=crc;
  223.  }
  224.  
  225.  crc=0xffff;
  226.  for (adr=0;adr<0x1dffe;adr++) crc=tabcrc[(crc>>8)^buff[adr]]^(crc<<8);
  227.  buff[0x1dffe]=crc>>8;
  228.  buff[0x1dfff]=crc&0xff;
  229.  
  230.  segadr=0x40;
  231.  adr=0;
  232.  do
  233.  {
  234.   m=0;
  235.   b=0xff;
  236.   for (i=0;i<256;i++) b&=buff[adr++];
  237.   if (b!=0xff) m|=0x01;
  238.   b=0xff;
  239.   for (i=0;i<256;i++) b&=buff[adr++];
  240.   if (b!=0xff) m|=0x02;
  241.   b=0xff;
  242.   for (i=0;i<256;i++) b&=buff[adr++];
  243.   if (b!=0xff) m|=0x04;
  244.   b=0xff;
  245.   for (i=0;i<256;i++) b&=buff[adr++];
  246.   if (b!=0xff) m|=0x08;
  247.   b=0xff;
  248.   for (i=0;i<256;i++) b&=buff[adr++];
  249.   if (b!=0xff) m|=0x10;
  250.   b=0xff;
  251.   for (i=0;i<256;i++) b&=buff[adr++];
  252.   if (b!=0xff) m|=0x20;
  253.   b=0xff;
  254.   for (i=0;i<256;i++) b&=buff[adr++];
  255.   if (b!=0xff) m|=0x40;
  256.   b=0xff;
  257.   for (i=0;i<256;i++) b&=buff[adr++];
  258.   if (b!=0xff) m|=0x80;
  259.   header[segadr++]=m;
  260.  }
  261.  while (adr<0x1e000);
  262.  
  263.  crc=0x0000;
  264.  for (i=0;i<0x7e;i++) crc=tabcrc[(crc>>8)^header[i]]^(crc<<8);
  265.  header[0x7e]=crc>>8;
  266.  header[0x7f]=crc&0xff;
  267.  
  268.  f=fopen("ZXEVO_FW.BIN","wb");
  269.  if (!f) { printf("Can't create output file!\n"); return 1; }
  270.  fwrite(header,1,0x80,f);
  271.  adr=0;
  272.  do
  273.  {
  274.   b=0xff;
  275.   for (i=0;i<256;i++) b&=buff[adr++];
  276.   if (b!=0xff) fwrite(&buff[adr-256],256,1,f);
  277.  }
  278.  while (adr<0x1e000);
  279.  fclose(f);
  280.  printf("Created file ZXEVO_FW.BIN\n");
  281.  return 0;
  282. }
  283.