ul_sendhex.c

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

int send_cmd_go(int addr)
{ int ret;
  int i;
  ul_fd_t ul_fd;
  uchar buf[8];
  ul_fd=ul_open(ul_dev_name, NULL);
  if(ul_fd==UL_FD_INVALID)
    { perror("send_cmd_go : uLan open failed");return -1;};
  i=0;
  buf[i++]=0x10;
  buf[i++]=(uchar)mem_type; buf[i++]=mem_type>>8;
  buf[i++]=(uchar)go_addr;  buf[i++]=go_addr>>8;
  if(mem_type&0x100)
    {buf[i++]=go_addr>>16;  buf[i++]=go_addr>>24;};
  ret=ul_send_command_wait(ul_fd,module,UL_CMD_DEB,
  			UL_BFL_ARQ|UL_BFL_PRQ,buf,i);
  if(ret<0) printf("Goto to %4X ERROR\n",addr);
  else printf("Goto to %4X OK\n",addr);
  ul_close(ul_fd);
  return ret;
};

int send_cmd_res(void)
{ int ret;
  int i;
  ul_fd_t ul_fd;
  uchar buf[8];
  ul_fd=ul_open(ul_dev_name, NULL);
  if(ul_fd==UL_FD_INVALID)
    { perror("send_cmd_res : uLan open failed");return -1;};
  i=0;
  buf[i++]=ULRES_CPU;
  buf[i++]=0x55;
  buf[i++]=0xaa;
  ret=ul_send_command_wait(ul_fd,module,UL_CMD_RES,
  			UL_BFL_ARQ|UL_BFL_PRQ,buf,i);
  if(ret<0) printf("Module %d reset ERROR\n", module);
  else printf("Module %d reset OK\n", module);
  ul_close(ul_fd);
  return ret;
};

#define MEM_FILL_ATONCE 1024

int mem_fill(int mem_type, unsigned long start, unsigned long len,
		unsigned char *pat_val, int pat_len)
{
  ul_fd_t ul_fd;
  int in_proc_msg=0;
  ul_msginfo msginfo;
  int ret, stamp;
  unsigned long addr=start;
  unsigned char buff[MEM_FILL_ATONCE];
  int blen=MEM_FILL_ATONCE;
  unsigned char *p;
  int cnt;
  int i;

  if(pat_len<=0) return -1;

  ul_fd=ul_open(ul_dev_name, NULL);
  if(ul_fd==UL_FD_INVALID)
    { perror("mem_fill : uLan open failed");return -1;};

  if(blen>max_block) blen=max_block;

  if((pat_len<=blen/2)&&(len>pat_len)){
    i=blen<len+pat_len?blen:len+pat_len-1;
    if((pat_len==1)){
      blen=i;
      memset(buff,*pat_val,blen);
    }else{
      i=i/pat_len;
      blen=i*pat_len;
      for(p=buff;i;i--,p+=pat_len){
        memcpy(p,pat_val,pat_len);
      }
    }
    pat_val=buff;
  } else {
    blen=pat_len;
  }
  
  while(len || in_proc_msg){
    while(in_proc_msg<3){
      cnt=(len>blen)?blen:len;
      stamp=ret=ul_new_memrq_write(ul_fd, module, mem_type, addr, cnt, pat_val);
      if(ret<0){
	fprintf(stderr,"mem_fill: uniload_mem_write returned %d\n", ret);
	ul_close(ul_fd);
	return -1;
      }
      len-=cnt;
      addr+=cnt;
      in_proc_msg++;
    }
    if(in_proc_msg){
      if(ul_fd_wait(ul_fd,10)<=0) 
      { printf("mem_fill : select error\n");
        ret=-1; break;
      };
      if(ul_acceptmsg(ul_fd,&msginfo)<0)
      { printf("mem_fill : accept msg error\n");
        ret=-1; break;
      };
      if(msginfo.flg&UL_BFL_FAIL)
      { printf("mem_fill : target system error\n");
        ret=-1; break;
      };
      ul_freemsg(ul_fd);
      in_proc_msg--;
    }
  }
  ul_close(ul_fd);
  return 0;  
}

int print_modules(int max_addr)
{ int ret;
  int i;
  ul_fd_t ul_fd;
  uchar *p;
  void *buf=NULL;
  int buf_len;
  int count=0; 
  ul_fd=ul_open(ul_dev_name, NULL);
  if(ul_fd==UL_FD_INVALID)
    { perror("print_modules : uLan open failed");return -1;};
  for(i=1;i<=max_addr;i++)
  {
    ret=ul_send_query_wait(ul_fd,i,UL_CMD_SID,
  			UL_BFL_NORE|UL_BFL_PRQ,NULL,0,&buf,&buf_len);
    if(ret>=0)
    { count++;
      p=(uchar*)buf;
      for(ret=0;(ret<buf_len)&&*p;ret++,p++);
      printf("%2d:  ",i);
      fwrite(buf,ret,1,stdout);
      printf("\n");
    };
    if(buf) free(buf);
    buf=NULL;
  };
  ul_close(ul_fd);
  return count;
};

int debug_kernel(int debug_msk)
{ int ret;
  ul_fd_t ul_fd;
  ul_fd=ul_open(ul_dev_name, NULL);
  if(ul_fd==UL_FD_INVALID)
    { perror("debug_kernel : uLan open failed");return -1;};
  ret=ul_drv_debflg(ul_fd,debug_msk);
  ul_close(ul_fd);
  return ret;
};

int upload_file(char *file_name, char *format)
{
  ul_fd_t ul_fd;
  FILE *file;
  int ret;
  uchar buf[0x400];
  uchar *p;
  char *mode="w";
  enum {fmt_ihex, fmt_binary, fmt_dump} fmt;
  int i,l,csum; 
  int mem_adr=mem_start;
  int mem_len=mem_length;
  int len;

  if(max_block>0x400) max_block=0x400;

  if(!format || !strcmp("ihex",format)){
    fmt=fmt_ihex;
  } else if(!strcmp("binary",format)){
    mode="wb";
    fmt=fmt_binary;
  } else if(!strcmp("dump",format)){
    fmt=fmt_dump;
  } else {
    fprintf(stderr, "requested unknown format %s\n", format);
    return -1;
  }
  
  if(!strcmp(file_name,"-")) file_name=NULL;

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

  if(file_name){
    if((file=fopen(file_name,mode))==NULL)
    {perror("upload_file : file open");
     ul_close(ul_fd);
     return -1;
    }
  } else file=stdout;

  while(mem_len)
  { len=mem_len<max_block?mem_len:max_block;
    ret=ul_mem_read_wait(ul_fd,module,mem_type,mem_adr,len,buf);
    if(ret<0) 
    { printf("Mem read returns %d\n",ret);
      break;
    }
    if(file_name) printf("%04X\n",mem_adr);
    switch(fmt){
      case fmt_ihex:
	p=buf; i=0;
	while(i<len)
	{
	 l=len-i;
	 if(l>16) l=16;
	 csum=l+(mem_adr+i)+((mem_adr+i)>>8);
	 fprintf(file,":%02X%04X00",l,mem_adr+i);
	 while(l--) {fprintf(file,"%02X",buf[i]);csum+=buf[i++];};
	 fprintf(file,"%02X\n",(-csum)&0xFF);
	}
	break;
      case fmt_binary:
	if(fwrite(buf,len,1,file)!=1){
	  perror("upload_file : file write");
	  return -1;
	}
	break;
      case fmt_dump:
        i=0; p=buf;
	while(i<len){
	  if(i&0xf) printf(" %02X",*(p++));
	  else printf(i?"\n%04X:%02X":"%04X:%02X",mem_adr+i,*(p++));
	  i++;
	}
	printf("\n");
	break;
    }
    mem_adr+=len;
    mem_len-=len;
  }

  if(file_name) fclose(file); 
  ul_close(ul_fd);
 
  return 0;
};

int mem_erase(int mem_type, int start, int len)
{
  int ret;
  int i;
  ul_fd_t ul_fd;
  uchar buf[8];
  ul_fd=ul_open(ul_dev_name, NULL);
  if(ul_fd==UL_FD_INVALID)
    { perror("mem_erase : uLan open failed");return -1;};
  i=0;
  buf[i++]=(uchar)mem_type; buf[i++]=mem_type>>8;
  buf[i++]=(uchar)start;  buf[i++]=start>>8;
  if(mem_type&0x100)
    {buf[i++]=start>>16;  buf[i++]=start>>24;};
  buf[i++]=(uchar)len;   buf[i++]=len>>8;
  if(mem_type&0x100)
    {buf[i++]=len>>16;  buf[i++]=len>>24;};
  ret=ul_send_command_wait(ul_fd,module,UL_CMD_ERM,
  			UL_BFL_ARQ|UL_BFL_PRQ,buf,i);
  if(ret<0) printf("erase from:0x%4X to:0x%4X ERROR\n",start,start+len);
  else printf("erase from:0x%4X to:0x%4X OK\n",start,start+len);
  ul_close(ul_fd);
  return ret;
}

int activate_boot(void)
{
  ul_fd_t ul_fd;
  int ret,in_boot=0;
  ul_msginfo msginfo;
  unsigned int rsn;
  uchar buf[5];

  ul_fd=ul_open(ul_dev_name, NULL);
  if(ul_fd==UL_FD_INVALID)
    { perror("stay_in_boot : uLan open failed");return -1;};
  memset(&msginfo,0,sizeof(msginfo));
  msginfo.cmd=UL_CMD_NCS;   
  ret=ul_addfilt(ul_fd,&msginfo);
  if(ret<0) { printf("stay_in_boot : add filter failed\n");return ret;};   
  while(!in_boot) {
    if(ul_acceptmsg(ul_fd,&msginfo)<0) {
      buf[0]=(uchar)ULNCS_BOOT_ACT;
      buf[1]=(uchar)sn;  buf[2]=sn>>8;
      buf[3]=sn>>16;  buf[4]=sn>>24;
      ul_send_command(ul_fd,module,UL_CMD_NCS,0,buf,5);
      #ifdef _WIN32
        Sleep(1000);
      #else
        sleep(1);
      #endif 
    } else {
      if ((msginfo.cmd==UL_CMD_NCS) && (msginfo.len==5)) {
        if((ret=ul_read(ul_fd,&buf,5))!=msginfo.len) { 
          printf("Bad read len %d, rq %d, msg %d\n",ret,5,msginfo.len);
          ul_freemsg(ul_fd);return -1;
        };
        rsn=(unsigned long)buf[1];
        rsn+=(unsigned long)buf[2]<<8;
        rsn+=(unsigned long)buf[3]<<16;
        rsn+=(unsigned long)buf[4]<<24;
        if ((buf[0]==ULNCS_BOOT_ACK) && (rsn==sn))
          in_boot=1;
      }  
      ul_freemsg(ul_fd);
    }
  }
  ul_close(ul_fd);
  return 0;
}

static void
usage(void)
{
  printf("usage: ul_sendhex <parameters> <hex_file>\n");
  printf("  -d, --uldev  <name>      name of uLan device [/dev/ulan]\n");
  printf("  -m, --module <num>       download/upload target uLan module\n");
  printf("  -t, --type   <num>       target module memory space\n");
  printf("  -s, --start  <addr>      start address of transfer\n");
  printf("  -l, --length <num>       length of upload block\n");
  printf("  -b, --block  <num>       maximal block length\n");
  printf("  -A, --align-order <num>  force block alignment\n");
  printf("  -g, --go     <addr>      start program from address\n");
  printf("  -r, --reset              reset before download\n");
  printf("  -u, --upload             upload memory block [download]\n");
  printf("  -F, --fill <num>         fill region defined by -s -l by value\n");
  printf("  -e, --erase              erase memory defined by -s -l -t\n");
  printf("  -o, --bootloader <sn>    activate bootloader\n");
  printf("  -f, --format <format>    format of data file [ihex]\n");
  printf("  -p, --print  <max>       print modules to max address\n");
  printf("      --debug-kernel <m>   flags to debug kernel\n");
  printf("  -V, --version            show version\n");
  printf("  -h, --help               this usage screen\n");
}

int main(int argc,char *argv[])
{
  static struct option long_opts[] = {
    { "uldev", 1, 0, 'd' },
    { "module",1, 0, 'm' },
    { "type",  1, 0, 't' },
    { "start", 1, 0, 's' },
    { "length",1, 0, 'l' },
    { "block", 1, 0, 'b' },
    { "align-order", 1, 0, 'A' },
    { "go",    1, 0, 'g' },
    { "reset", 0, 0, 'r' },
    { "upload",0, 0, 'u' },
    { "fill",  1, 0, 'F' },
    { "erase", 0, 0, 'e' },
    { "bootloader", 1, 0, 'o' },
    { "format",1, 0, 'f' },
    { "print", 1, 0, 'p' },
    { "version",0,0, 'V' },
    { "help",  0, 0, 'h' },
    { "debug-kernel", 1, 0, 'D' },
    { 0, 0, 0, 0}
  };
  int opt;

 #ifndef HAS_GETOPT_LONG
  while ((opt = getopt(argc, argv, "d:m:t:s:l:b:g:ruF:ef:o:p:VhD:")) != EOF)
 #else
  while ((opt = getopt_long(argc, argv, "d:m:t:s:l:b:g:ruF:ef:o:p:Vh",
			    &long_opts[0], NULL)) != EOF)
 #endif
    switch (opt) {
    case 'd':
      ul_dev_name=optarg;
      break;
    case 'm':
      module = strtol(optarg,NULL,0);
      break;
    case 't':
      mem_type = strtol(optarg,NULL,0);
      break;
    case 's':
      mem_start = strtol(optarg,NULL,0);
      break;
    case 'l':
      mem_length = strtol(optarg,NULL,0);
      break;
    case 'b':
      max_block = strtol(optarg,NULL,0);
      break;
    case 'A':
      align_order = strtol(optarg,NULL,0);
      break;
    case 'g':
      go_addr = strtol(optarg,NULL,0);
      go_flg = 1;
      break;
    case 'r':
      reset_flg = 1;
      break;
    case 'u':
      upload_flg = 1;
      break;
    case 'F':
      fill_flg=1;
      if(add_to_arr((void**)&fill_pat_val,&fill_pat_len,0,optarg)<0){
	fprintf(stderr,"%s: incorrect patern data \"%s\"\n",argv[0],optarg);
	exit(2);
      }
      if(!fill_pat_len){
	fprintf(stderr,"%s: incorrect patern data - empty value\n",argv[0]);
	exit(2);
      }
      break;
    case 'e':
      erase_flg = 1;
      break;
    case 'o':
      boot_flg = 1;
      sn = strtol(optarg,NULL,0);
      break;
    case 'f':
      file_format=optarg;
      break;
    case 'p':
      prt_modules = strtol(optarg,NULL,0);
      break;
    case 'D':
      debugk = strtol(optarg,NULL,0);
      debugk_flg=1;
      break;
    case 'V':
      fputs("uLan sendhex v0.7\n", stdout);
      exit(0);
    case 'h':
    default:
      usage();
      exit(opt == 'h' ? 0 : 1);
    }

  if ((optind >= argc)&&!go_flg&&!reset_flg&&!prt_modules&&
      !debugk_flg&&!erase_flg&&!boot_flg) 
  { usage();
    exit(1);
  }
  
  if(debugk_flg) debug_kernel(debugk);

  if(prt_modules) print_modules(prt_modules);

  if(reset_flg) {
    if(send_cmd_res()<0) exit(2);
  }

  if(boot_flg) {
    if(activate_boot()<0) exit(2);
  }

  if(fill_flg) {
    mem_fill(mem_type, mem_start, mem_length?mem_length:fill_pat_len, fill_pat_val, fill_pat_len);
  }

  if(erase_flg) {
    mem_erase(mem_type, mem_start, mem_length);
  }

  if(!upload_flg)
  { while (optind < argc)
      if(download_file(argv[optind++], file_format)<0) exit(2);
  }else{
    if(optind+1!=argc) 
    { printf("upload_file : needs exactly one filename\n");
      exit(1);
    };
    if(upload_file(argv[optind], file_format)<0) exit(2);
  };
  
  if(go_flg)
  { if(send_cmd_go(go_addr)<0) exit(2);;
  };

  return 0;
}