ul_sendhex.c

一个linux下rs485驱动程序的源代码

/*******************************************************************
  uLan Communication - simple test client

  ul_sendhex.c	- intelhex downloader

  (C) Copyright 1996,1999 by Pavel Pisa 

  The uLan driver is distributed under the Gnu General Public Licence. 
  See file COPYING for details.
 *******************************************************************/

#ifndef _MSC_VER
#include <sys/time.h>
#include <unistd.h>
#endif /*_MSC_VER*/
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <stdio.h>
#include <getopt.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <ul_lib/ulan.h>

int ul_new_memrq_head(ul_fd_t ul_fd, int dadr, int cmd, 
                      int mtype, int start, int len)
{
  int ret;
  int i;
  ul_msginfo msginfo;
  uchar buf[8];
  msginfo.dadr=dadr;
  msginfo.cmd=cmd;
  msginfo.flg=UL_BFL_ARQ|UL_BFL_PRQ|UL_BFL_M2IN;
  ret=ul_newmsg(ul_fd,&msginfo);
  if(ret<0) return ret;
  i=0;
  buf[i++]=(uchar)mtype; buf[i++]=mtype>>8;
  buf[i++]=(uchar)start; buf[i++]=start>>8;
  if(mtype&0x100)
    {buf[i++]=start>>16; buf[i++]=start>>24;};
  buf[i++]=(uchar)len;   buf[i++]=len>>8;
  if(ul_write(ul_fd,buf,i)!=i)
  { ul_abortmsg(ul_fd);
    ret=-1;
  };
  return ret;
};

int ul_new_memrq_read(ul_fd_t ul_fd, int dadr,
                      int mtype, int start, int len)
{
  int ret;
  ul_msginfo msginfo;
  ret=ul_new_memrq_head(ul_fd,dadr,UL_CMD_RDM,mtype,start,len);
  if (ret<0) return ret;
  msginfo.dadr=dadr;
  msginfo.cmd=UL_CMD_RDM&0x7F;
  msginfo.flg=UL_BFL_REC|UL_BFL_LNMM|UL_BFL_M2IN;
  msginfo.len=len;
  ret=ul_tailmsg(ul_fd,&msginfo);
  if (ret<0) {ul_abortmsg(ul_fd);return ret;};
  ret=ul_freemsg(ul_fd);
  return ret;
};

int ul_new_memrq_write(ul_fd_t ul_fd, int dadr,
                       int mtype, int start, int len, void *buf)
{
  int ret;
  ul_msginfo msginfo;
  ret=ul_new_memrq_head(ul_fd,dadr,UL_CMD_WRM,mtype,start,len);
  if(ret<0) return ret;
  msginfo.dadr=dadr;
  msginfo.cmd=UL_CMD_WRM&0x7F;
  msginfo.flg=UL_BFL_SND|UL_BFL_LNMM|UL_BFL_ARQ|UL_BFL_M2IN;
  msginfo.len=len;
  ret=ul_tailmsg(ul_fd,&msginfo);
  if(ret<0) {ul_abortmsg(ul_fd);return ret;};
  if(buf)
  { ret=ul_write(ul_fd,buf,len);
    if(ret<0) {ul_abortmsg(ul_fd);return ret;};
    ret=ul_freemsg(ul_fd);
  };
  return ret;
};

int ul_mem_read_wait(ul_fd_t ul_fd, int dadr,
                     int mtype, int start, int len, void *ptr)
{
  int ret, stamp;
  ul_msginfo msginfo;
 
  stamp=ret=ul_new_memrq_read(ul_fd,dadr,mtype,start,len);
  if(ret<0) return ret;

  /* ioctl(ul_fd,UL_KLOGBLL); */

  /* ioctl(ul_fd,UL_STROKE); */

  do {
    ul_freemsg(ul_fd);
    ret=ul_fd_wait(ul_fd,10);
    if(ret<0) {printf("Select returned %d\n",ret);return ret;};
    if(!ret) {printf("Select - timeout\n");return -1;};
    ret=ul_acceptmsg(ul_fd,&msginfo);
    if(ret<0)
    { printf("Accept msg returned %d\n",ret);
      return ret;
    };
  } while(msginfo.stamp!=stamp);
  if(msginfo.flg&UL_BFL_FAIL) 
  { printf("Failed msg flg=0x%X\n",msginfo.flg);
    ul_freemsg(ul_fd);return -1;
  };
 
  ret=ul_actailmsg(ul_fd,&msginfo);
  if(ret<0) 
  { printf("Accept tail returned %d\n",ret);
    ul_freemsg(ul_fd);
    return ret;
  };
  if((ret=ul_read(ul_fd,ptr,len))!=len)
  { printf("Bad read len %d, rq %d, msg %d\n",ret,len,msginfo.len);
    ul_freemsg(ul_fd);return -1;
  };
  
  ul_freemsg(ul_fd);
  return len;
};

/*******************************************************************/

typedef struct tform_file {
	uchar *buf;
	int   buf_len;
	int   buf_addr;
	int   buf_bytes;
	int   buf_rem_bytes;
	FILE *file;
	uchar *line_buf;
	int  line_addr;
	int  line_bytes;
	int  line_offs;
	int  start_addr;
	int (*read)(struct tform_file *tform);
	int (*done)(struct tform_file *tform);
  } tform_file;

#ifndef HAS_GETDELIM
int getdelim(char **line,unsigned *linelen,char delim,FILE *F)
{
 char c;
 int  l=0;
 do{
  if(l+1>=*linelen)
  {
   *linelen=l+20;
   if(!*line) *line=(char *)malloc(*linelen);
    else *line=(char *)realloc(*line,*linelen);
  }
  c=fgetc(F);
  if(feof(F)) {if(l) break; else return -1;}
  if(c!='\r') (*line)[l++]=c;
 } while(c!=delim);
 (*line)[l]=0;
 return l;
};
#endif

int get_hex(uchar **p, unsigned *v, int chars)
{
  unsigned u=0;
  uchar c;
  *v=0;
  while(**p==' ') (*p)++;
  while(chars--)
  { u<<=4;
    c=**p;
    if((c>='0')&&(c<='9')) u+=c-'0';
    else if((c>='A')&&(c<='F')) u+=c-'A'+10;
    else return -1;
    (*p)++;
  };
  *v=u;
  return 0;
};

int tform_init(tform_file *tform, int buf_len)
{
  if(!buf_len) buf_len=1024;
  tform->file=NULL;
  tform->buf_len=buf_len;
  tform->buf=malloc(tform->buf_len);
  tform->buf_addr=0;
  tform->line_buf=NULL;
  tform->line_offs=0;
  tform->line_bytes=0;
  tform->start_addr=-1;
  tform->buf_bytes=0;
  tform->buf_rem_bytes=0;
  tform->read=NULL;
  tform->done=NULL;
  return 0;
};

int tform_done(tform_file *tform)
{
  if(tform->done)
    return tform->done(tform);
  fclose(tform->file);
  if(tform->buf)free(tform->buf);
  if(tform->line_buf)free(tform->line_buf);
  return 0;
};

int tform_read(tform_file *tform)
{
  return tform->read(tform);
}

int tform_read_ihex(tform_file *tform)
{ int cn,len=0;
  int addr=0;
  unsigned u,v;
  uchar *p,*r;
  char *line=NULL;
  int  line_len=0;

  if(tform->buf_rem_bytes){
    int aoffs=tform->line_bytes-tform->buf_rem_bytes;
    memmove(tform->buf,tform->buf+aoffs,tform->buf_rem_bytes);
    addr=tform->buf_addr+=aoffs;
    len=tform->buf_rem_bytes;
  }

  while(len<tform->buf_len)
  {
    if(!tform->line_bytes)
    { int checksum=0;
      int ihex_type=0;

      tform->line_offs=0;
      if(getdelim(&line,&line_len,'\n',tform->file)==-1) break;
      p=line;
      if(*p++!=':') printf("tform_read : strange line %s\n",line);
      else {
       if(get_hex(&p,&u,2)<0) {printf("tform_read_ihex : bad ihex cnt\n");return -1;};
       checksum+=cn=tform->line_bytes=u;
       if(!tform->line_buf) tform->line_buf=malloc(cn);
       else tform->line_buf=realloc(tform->line_buf,cn);
       if(get_hex(&p,&u,2)<0) {printf("tform_read_ihex : bad ihex addr\n");return -1;};
       if(get_hex(&p,&v,2)<0) {printf("tform_read_ihex : bad ihex addr\n");return -1;};
       checksum+=u+v; tform->line_addr=(u<<8)+v;
       if(get_hex(&p,&u,2)<0) {printf("tform_read_ihex : bad ihex type\n");return -1;};
       checksum+=ihex_type=u;       
       if(ihex_type==0||ihex_type==1)
       {
         r=tform->line_buf;
         while(cn--)
         { if(get_hex(&p,&u,2)<0) {printf("tform_read_ihex : bad ihex data\n");return -1;};
           checksum+=*r++=u;
         
         };
         if(get_hex(&p,&u,2)<0) {printf("tform_read_ihex : bad ihex csum\n");return -1;};
         checksum+=u;
         if(checksum&0xff) 
         { printf("tform_read_ihex : error ihex csum %d\n",
                   checksum);return -1;
         };
         while((u=*p++)) if(u!=' '&&u!='\n'&&u!='\r')
           {printf("tform_read_ihex : residual chars on line\n");return -1;};
       };
       if(ihex_type==1)
       { tform->line_bytes=0;
	 tform->start_addr=tform->line_addr;
       };
      };
    };
    if(tform->line_bytes)
    { if(!len) addr=tform->buf_addr=tform->line_addr+tform->line_offs;
      else if(addr!=tform->line_addr+tform->line_offs) break;
      cn=tform->line_bytes-tform->line_offs;
      if(cn+len>tform->buf_len) cn=tform->buf_len-len;
      memcpy(tform->buf+len,tform->line_buf+tform->line_offs,cn);
      len+=cn;
      addr+=cn;
      tform->line_offs+=cn;
      if(tform->line_bytes==tform->line_offs) tform->line_bytes=0;
    };
  };
  tform->buf_bytes=len;
  tform->buf_rem_bytes=0;
  return len;
};

int tform_read_binary(tform_file *tform)
{
  int len=0;

  tform->buf_addr+=tform->buf_bytes;
  len=fread(tform->buf,1,tform->buf_len,tform->file);
  if(len<0) {
    perror("tform_read_binary : read error");
    return -1;
  }

  tform->buf_bytes=len;
  return len;
}

int tform_open(tform_file *tform,char *file_name,
               char *format, int buf_len, int wr_fl)
{
  FILE *file;

  if(!format || !strcmp("ihex",format))
  {
    if((file=fopen(file_name,"r"))==NULL)
    {perror("download_file : hex file open");
      return -1;
    };
    tform_init(tform,buf_len);
    tform->file=file;
    tform->read=tform_read_ihex;
  } 
  else if(!strcmp("binary",format))
  {
    if((file=fopen(file_name,"rb"))==NULL)
    {perror("download_file : binary file open");
      return -1;
    };
    tform_init(tform,buf_len);
    tform->file=file;
    tform->read=tform_read_binary;
  } else {
    fprintf(stderr, "requested unknown format %s\n", format);
    return -1;
  }
  return 1;
}

/*******************************************************************/

int si_long(char **ps,long *val,int base)
{
  char *p;
  *val=strtol(*ps,&p,base);
  if(*ps==p) return -1;
  *ps=p;
  return 1;
}

int add_to_arr(void **pdata,int *plen,int base,char *str)
{
  char *s=str;
  long val;
  void *p;

  do{
    while(*s && strchr(", \t:;",*s)) s++;
    if(!*s) break;
    if(si_long(&s,&val,base)<0){
      return -1;
    }
    if(*pdata==NULL){
      *plen=0;
      *pdata=p=malloc(1);
    }else{
      p=realloc(*pdata,*plen+1);
      if(p==NULL) return -1;
      *pdata=p;
    }
    ((unsigned char*)p)[*plen]=val;
    (*plen)++;
  } while(1);
  return 1;
}

/*******************************************************************/

char *ul_dev_name = UL_DEV_NAME;
int module     = 3;
int upload_flg = 0;
int mem_type   = 2;
int mem_start  = 0;
int mem_length = 0xff00;
int max_block  = 1024;
int align_order= 0;
int go_addr    = 3;
int go_flg     = 0;
int reset_flg  = 0;
int prt_modules= 0;
int debugk     = 0;
int debugk_flg = 0;
int fill_flg   = 0;
int erase_flg  = 0;
int boot_flg   = 0;
void *fill_pat_val;
int fill_pat_len;
char *file_format=NULL;
unsigned int sn=0;

int download_file(char *file_name, char *format)
{
  ul_fd_t ul_fd;
  tform_file tform;
  int len;  
  int ret=0;
  int stamp;
  ul_msginfo msginfo;
  int in_proc_msg=0;
  int shift_addr=0;
  int addr;
  unsigned align_size=(1<<align_order);

  shift_addr=mem_start;

  ul_fd=ul_open(ul_dev_name, NULL);
  if(ul_fd==UL_FD_INVALID)
    { perror("download_file : uLan open failed");return -1;};
  /* ul_drv_debflg(ul_fd,0x11); */ /* 0x9 0x11 */ 

  if (tform_open(&tform, file_name, format, max_block, 0)<0)
  {
    ul_close(ul_fd);
    return -1;
  }

  do
  { 
    while(in_proc_msg<3)
    { len=tform_read(&tform);
      if(!len) break;
      if(len<0) 
      { perror("download_file : ihex");
        ret=-1;
        break;
      };

      printf("addr %4X len %4X\n",tform.buf_addr+shift_addr,len);

      addr=tform.buf_addr+shift_addr;

      if(align_order){
        int rem=len+((align_size-1)&addr);
        if(rem>align_size){
	  rem-=align_size;
	  len-=rem;
	  tform.buf_rem_bytes=rem;
	}
      }

      if((stamp=ul_new_memrq_write(ul_fd,module,mem_type,addr,len,tform.buf))<0)
      { printf("download_file : send message error\n");
        ret=-1; break;
      };
      in_proc_msg++;
    };
    if(ret<0) break;
    if(in_proc_msg)
    { if(ul_fd_wait(ul_fd,10)<=0) 
      { printf("download_file : select error\n");
        ret=-1; break;
      };
      if(ul_acceptmsg(ul_fd,&msginfo)<0)
      { printf("download_file : accept msg error\n");
        ret=-1; break;
      };
      if(msginfo.flg&UL_BFL_FAIL)
      { printf("download_file : target system error\n");
        ret=-1; break;
      };
      ul_freemsg(ul_fd);
      in_proc_msg--;
      /* printf(">>> "); */
    };
  } while(in_proc_msg);
  
  if(tform.start_addr!=-1) 
    printf("Found start address %4X\n",tform.start_addr);
  tform_done(&tform);

  ul_close(ul_fd);

  return ret;
};