betty/lpcload.c

   1 /*
   2  * lpcload.c - load firmware into ram of lpc2220 via uart0
   3  *
   4  * author: hackbard@hackdaworld.org, rolf.anders@physik.uni-augsburg.de
   5  *
   6  * build: make
   7  * usage: sudo ./lpcload -d /dev/ttyS0 -f firmware.hex -D0 fw0.bin [-v]
   8  */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <unistd.h>
  14 #include <sys/types.h>
  15 #include <sys/stat.h>
  16 #include <fcntl.h>
  17 #include <termios.h>
  18
  19 #define VERBOSE                 (1<<0)
  20 #define FIRMWARE                (1<<1)
  21 #define BANK0                   (1<<2)
  22 #define BANK2                   (1<<3)
  23 #define BL                      (1<<4)
  24 #define FLASHFW                 (1<<5)
  25
  26 #define BANK0_ADDR              0x80000000
  27 #define BANK2_ADDR              0x82000000
  28 #define BANK_SIZE               0x00100000
  29 #define BL_ADDR                 0x7fffe000
  30 #define BL_SIZE                 0x00002000
  31
  32 #define CMD_READ                'R'             // stay compatible to fwflash!
  33 #define CMD_WRITE               'W'
  34 #define CMD_CHIP_ERASE          'E'
  35
  36 #define TXRX_TYPE_SYNC          0x00
  37 #define TXRX_TYPE_CKSM          0x00
  38 #define TXRX_TYPE_BAUD          0x01
  39 #define TXRX_TYPE_CMD           0x02
  40 #define TXRX_TYPE_DATA          0x03
  41 #define TXRX_TYPE_GO            0x04
  42
  43 #define CMD_SUCCESS             "0\r\n"
  44 #define INVALID_COMMAND         "1\r\n"
  45 #define SRC_ADDR_ERROR          "2\r\n"
  46 #define DST_ADDR_ERROR          "3\r\n"
  47 #define SRC_ADDR_NOT_MAPPED     "4\r\n"
  48 #define DST_ADDR_NOT_MAPPED     "5\r\n"
  49 #define COUNT_ERROR             "6\r\n"
  50 #define COMPARE_ERROR           "10\r\n"
  51 #define BUSY                    "11\r\n"
  52 #define PARAM_ERROR             "12\r\n"
  53 #define ADDR_ERROR              "13\r\n"
  54 #define ADDR_NOT_MAPPED         "14\r\n"
  55 #define CMD_LOCKED              "15\r\n"
  56 #define INVALID_CODE            "16\r\n"
  57 #define INVALID_BAUD_RATE       "17\r\n"
  58 #define INVALID_STOP_BIT        "18\r\n"
  59
  60 #define RAM                     0x01
  61 #define FLASH                   0x02
  62
  63 #define CRYSTFREQ               "10000"
  64 #define RAMOFFSET               0x40000200
  65
  66 #define BUFSIZE                 128
  67
  68 typedef unsigned char u8;
  69 typedef unsigned short u16;
  70 typedef unsigned int u32;
  71
  72 typedef struct s_lpc {
  73         int sfd;                /* serial fd */
  74         char sdev[128];         /* seriel device */
  75         int fwfd;               /* fimrware fd */
  76         char fwfile[128];       /* firmware file */
  77         u32 info;               /* info/mode */
  78         char freq[8];           /* frequency */
  79         char bank0[127];        /* flash dump bank0 */
  80         int b0fd;               /* dumpfile fd bank0 */
  81         char bank2[127];        /* flash dump bank2 */
  82         int b2fd;               /* dumpfile fd bank0 */
  83         char bl[127];           /* flash dump bootloader */
  84         int blfd;               /* dumpfile fd bootloader */
  85         char ffwfile[127];      /* file with firmware to be flashed */
  86         int ffwfd;              /* fd of the above */
  87         u32 roff;               /* ram offset of uc */
  88         u32 jaddr;              /* addr for the jump */
  89 } t_lpc;
  90
  91 void usage(void) {
  92
  93         printf("possible argv:\n");
  94         printf("  -d  <serial device>\n");
  95         printf("  -f  <firmware>\n");
  96         printf("  -c  <crystal freq>\n");
  97         printf("  -Dx <filename>\n");
  98         printf("      x=0: bank0, x=2: bank2, x=b: bootloader\n");
  99         printf("  -w <firmware which goes to flash>\n");
 100         printf("  -v\n");
 101
 102 }
 103
 104 int open_serial_device(t_lpc *lpc) {
 105
 106         struct termios term;
 107
 108         //memset(&term,0,sizeof(struct termios));
 109
 110         /* open serial device */
 111
 112         lpc->sfd=open(lpc->sdev,O_RDWR);
 113         if(lpc->sfd<0) {
 114                 perror("tts open");
 115                 return lpc->sfd;
 116         }
 117
 118         /* configure the serial device */
 119
 120         tcgetattr(lpc->sfd,&term);
 121
 122         // input/output baudrate
 123
 124         cfsetispeed(&term,B38400);
 125         cfsetospeed(&term,B38400);
 126
 127         // control options -> 8n1
 128
 129         term.c_cflag&=~PARENB;  // no parity
 130         term.c_cflag&=~CSTOPB;  // only 1 stop bit
 131         term.c_cflag&=~CSIZE;   // no bit mask for data bits
 132         term.c_cflag|=CS8;      // 8 data bits
 133
 134         // line options -> raw input
 135
 136         term.c_lflag&=~(ICANON|ECHO|ECHOE|ISIG);
 137
 138         // input options -> enable flow control
 139
 140         term.c_iflag&=~(INLCR|ICRNL|IXANY);
 141         term.c_iflag|=(IXON|IXOFF);
 142
 143         // output options
 144
 145         term.c_oflag=0;
 146
 147         // more control options -> timeout / flow control
 148
 149         term.c_cc[VMIN]=0;
 150         term.c_cc[VTIME]=20;    // 2 seconds timeout
 151         //term.c_cc[VSTART]=0x11;
 152         //term.c_cc[VSTOP]=0x13;
 153
 154         tcsetattr(lpc->sfd,TCSANOW,&term);
 155
 156         return lpc->sfd;
 157 }
 158
 159 int reconfig_serial_device(t_lpc *lpc) {
 160
 161         struct termios term;
 162         int ret;
 163
 164         /* reconfigure the serial device for our lousy loader tool */
 165
 166         tcgetattr(lpc->sfd,&term);
 167
 168         // disable flow control
 169
 170         term.c_iflag&=~(IXON|IXOFF|IXANY|INLCR|ICRNL);
 171
 172         // change baudrate
 173
 174         cfsetispeed(&term,B115200);
 175         cfsetospeed(&term,B115200);
 176
 177         // timeouts
 178
 179         term.c_cc[VMIN]=0;
 180         term.c_cc[VTIME]=100;   // 10 seconds timeout
 181
 182         ret=tcsetattr(lpc->sfd,TCSANOW,&term);
 183
 184         return ret;
 185 }
 186
 187 int open_firmware(t_lpc *lpc) {
 188
 189         /* open firmware file */
 190
 191         lpc->fwfd=open(lpc->fwfile,O_RDONLY);
 192
 193         if(lpc->fwfd<0) {
 194                 perror("fw open");
 195                 return lpc->fwfd;
 196         }
 197
 198         if(lpc->info&FLASHFW) {
 199                 lpc->ffwfd=open(lpc->ffwfile,O_RDONLY);
 200                 if(lpc->ffwfd<0) {
 201                         perror("ffw open");
 202                         return lpc->ffwfd;
 203                 }
 204         }
 205
 206         return lpc->fwfd;
 207 }
 208
 209 int open_dumpfiles(t_lpc *lpc) {
 210
 211         /* open dumpfiles */
 212
 213         if(lpc->info&BANK0) {
 214                 lpc->b0fd=open(lpc->bank0,O_WRONLY|O_CREAT);
 215                 if(lpc->b0fd<0) {
 216                         perror("bank0 dump file open");
 217                         return lpc->b0fd;
 218                 }
 219         }
 220
 221         if(lpc->info&BANK2) {
 222                 lpc->b2fd=open(lpc->bank2,O_WRONLY|O_CREAT);
 223                 if(lpc->b2fd<0) {
 224                         perror("bank2 dump file open");
 225                         return lpc->b2fd;
 226                 }
 227         }
 228
 229         if(lpc->info&BL) {
 230                 lpc->blfd=open(lpc->bl,O_WRONLY|O_CREAT);
 231                 if(lpc->blfd<0) {
 232                         perror("bootloader dump file open");
 233                         return lpc->blfd;
 234                 }
 235         }
 236
 237         return 0;
 238
 239 }
 240 int txrx(t_lpc *lpc,char *buf,int len,u8 type) {
 241
 242         int ret,cnt;
 243         int i;
 244
 245         /* write */
 246
 247         if(lpc->info&VERBOSE)
 248                 printf("  >> ");
 249         cnt=0;
 250         while(len) {
 251                 ret=write(lpc->sfd,buf+cnt,len);
 252                 if(ret<0) {
 253                         perror("txrx write");
 254                         return ret;
 255                 }
 256                 if(lpc->info&VERBOSE)
 257                         for(i=0;i<ret;i++)
 258                                 printf("%c",
 259                                        ((buf[cnt+i]>0x19)&(buf[cnt+i]<0x7f))?
 260                                        buf[cnt+i]:'.');
 261                 len-=ret;
 262                 cnt+=ret;
 263         }
 264         if(lpc->info&VERBOSE) {
 265                 printf(" | ");
 266                 for(i=0;i<cnt;i++)
 267                         printf("%02x ",buf[i]);
 268                 printf("| (%d)\n",cnt);
 269         }
 270
 271
 272
 273         /* cut the echo if not of type auto baud */
 274
 275         if(type!=TXRX_TYPE_BAUD) {
 276                 while(cnt) {
 277                         ret=read(lpc->sfd,buf,cnt);
 278                         if(ret<0) {
 279                                 perror("txrx echo cut");
 280                                 return ret;
 281                         }
 282                         cnt-=ret;
 283                 }
 284         }
 285
 286         /* return if type is go */
 287
 288         if(type==TXRX_TYPE_GO)
 289                 return cnt;
 290
 291         /* return here if type is data */
 292
 293         if(type==TXRX_TYPE_DATA)
 294                 return cnt;
 295
 296         /* read */
 297
 298         ret=read(lpc->sfd,buf,1);
 299         if(ret<0) {
 300                 perror("txrx read (first byte)");
 301                 return ret;
 302         }
 303
 304         switch(buf[0]) {
 305                 case 'S':
 306                         cnt=13;
 307                         break;
 308                 case 'O':
 309                         cnt=3;
 310                         break;
 311                 case 'R':
 312                         cnt=7;
 313                         break;
 314                 case '0':
 315                         cnt=2;
 316                         break;
 317                 default:
 318                         printf("txrx read: bad return byte '%02x'\n",buf[0]);
 319                         break;
 320         }
 321
 322         ret=1;
 323         i=cnt;
 324         while(i) {
 325                 ret=read(lpc->sfd,buf+1+cnt-i,i);
 326                 if(ret<0) {
 327                         perror("txrx read (next bytes)");
 328                         return ret;
 329                 }
 330                 i-=ret;
 331         }
 332         if(lpc->info&VERBOSE) {
 333                 printf("  << ");
 334                 for(i=0;i<cnt+1;i++)
 335                         printf("%c",((buf[i]>0x19)&(buf[i]<0x7f))?
 336                                     buf[i]:'.');
 337                 printf(" | ");
 338                 for(i=0;i<cnt+1;i++)
 339                         printf("%02x ",buf[i]);
 340                 printf("| (%d)\n",cnt+1);
 341         }
 342         buf[cnt+1]='\0';
 343
 344         /* check/strip return code if type is cmd */
 345
 346         if(type==TXRX_TYPE_CMD) {
 347                 ret=strlen(CMD_SUCCESS);
 348                 if(!strncmp(buf,CMD_SUCCESS,ret)) {
 349                         for(i=ret;i<cnt;i++)
 350                                 buf[i-ret]=buf[i];
 351                         buf[cnt]='\0';
 352                 }
 353                 else {
 354                         printf("txrx bad return code!\n");
 355                         return -1;
 356                 }
 357         }
 358
 359         return cnt;
 360 }
 361
 362 int bl_init(t_lpc *lpc) {
 363
 364         char buf[BUFSIZE];
 365         int len;
 366
 367         /* auto baud sequence */
 368         buf[0]='?';
 369         txrx(lpc,buf,1,TXRX_TYPE_BAUD);
 370         if(strncmp(buf,"Synchronized\r\n",14)) {
 371                 printf("auto baud detection failed\n");
 372                 return -1;
 373         }
 374
 375         /* tell bl that we are synchronized (it's allready in buf) */
 376         txrx(lpc,buf,14,TXRX_TYPE_SYNC);
 377         if(strncmp(buf,"OK\r\n",4)) {
 378                 printf("sync failed\n");
 379                 return -1;
 380         }
 381
 382         /* tell bl the crystal frequency */
 383         len=strlen(lpc->freq)+2;
 384         strncpy(buf,lpc->freq,BUFSIZE);
 385         buf[len-2]='\r';
 386         buf[len-1]='\n';
 387         txrx(lpc,buf,len,TXRX_TYPE_SYNC);
 388         if(strncmp(buf,"OK\r\n",4)) {
 389                 printf("freq set failed\n");
 390                 return -1;
 391         }
 392
 393         return 0;
 394 }
 395
 396 int unlock_go(t_lpc *lpc) {
 397
 398         char buf[BUFSIZE];
 399         int ret;
 400
 401         memcpy(buf,"U 23130\r\n",9);
 402         ret=txrx(lpc,buf,9,TXRX_TYPE_CMD);
 403
 404         return ret;
 405 }
 406
 407 int go(t_lpc *lpc) {
 408
 409         char buf[BUFSIZE];
 410         int ret,len;
 411
 412         snprintf(buf,BUFSIZE,"G %d A\r\n",lpc->jaddr);
 413         len=strlen(buf);
 414         ret=txrx(lpc,buf,len,TXRX_TYPE_GO);
 415
 416         return ret;
 417 }
 418
 419 int uuencode(u8 *in,u8 *out,int len) {
 420
 421         out[0]=0x20+len;
 422         out[1]=0x20+((in[0]>>2)&0x3f);
 423         out[2]=0x20+(((in[0]<<4)|(in[1]>>4))&0x3f);
 424         out[3]=0x20+(((in[1]<<2)|(in[2]>>6))&0x3f);
 425         out[4]=0x20+(in[2]&0x3f);
 426
 427         return 0;
 428 }
 429
 430 int write_to_ram(t_lpc *lpc,char *buf,u32 addr,int len) {
 431
 432         int lcount;
 433         u32 checksum;
 434         char txrxbuf[BUFSIZE];
 435         int count,bcnt;
 436         int nlen,slen;
 437         int i;
 438
 439         /* check length */
 440         if(len%4) {
 441                 printf("ram write: not a multiple of 4\n");
 442                 return -1;
 443         }
 444
 445         /* make it a multiple of 3 (reason: uuencode) */
 446         nlen=(!(len%3))?len:((len/3+1)*3);
 447         if(nlen>BUFSIZE) {
 448                 printf("ram write: too much data\n");
 449                 return -1;
 450         }
 451         for(i=len;i<nlen;i++) buf[i]=0;
 452
 453         /* prepare addr */
 454         addr+=lpc->roff;
 455
 456         /* prepare write command */
 457         if(lpc->info&VERBOSE)
 458                 printf("writing 0x%02x bytes to 0x%08x\n",len,addr);
 459         snprintf(txrxbuf,BUFSIZE,"W %d %d\r\n",addr,len);
 460         slen=strlen(txrxbuf);
 461
 462         /* send command and check return code */
 463         txrx(lpc,txrxbuf,slen,TXRX_TYPE_CMD);
 464
 465         /* send data */
 466         lcount=0;
 467         bcnt=0;
 468         count=0;
 469         checksum=0;
 470         while(bcnt<nlen) {
 471
 472                 /* uuencode / prepare data bytes */
 473                 uuencode((u8 *)(buf+bcnt),(u8 *)(txrxbuf),
 474                          (bcnt==nlen-3)?(len%3?len%3:3):3);
 475                 txrxbuf[5]='\r';
 476                 txrxbuf[6]='\n';
 477
 478                 /* checksum */
 479                 checksum+=((u8)buf[bcnt]+(u8)buf[bcnt+1]+(u8)buf[bcnt+2]);
 480
 481                 /* send a data line */
 482                 txrx(lpc,txrxbuf,7,TXRX_TYPE_DATA);
 483
 484                 /* increase counters */
 485                 lcount+=1;
 486                 bcnt+=3;
 487                 count+=3;
 488
 489                 /* checksum */
 490                 if((!(lcount%20))|(bcnt==nlen)) {
 491                         /* send backtick */
 492                         memcpy(txrxbuf,"`\r\n",3);
 493                         //txrx(lpc,txrxbuf,3,TXRX_TYPE_DATA);
 494                         /* send checksum */
 495                         snprintf(txrxbuf,BUFSIZE,"%d\r\n",checksum);
 496                         slen=strlen(txrxbuf);
 497                         txrx(lpc,txrxbuf,slen,TXRX_TYPE_CKSM);
 498                         if(!strncmp(txrxbuf,"RESE",4)) {
 499                                 read(lpc->sfd,txrxbuf+4,4);
 500                                 printf("ram write: resending ...\n");
 501                                 bcnt-=count;
 502                         }
 503                         if(strncmp(txrxbuf,"OK\r\n",4)) {
 504                                 printf("ram write: bad response\n");
 505                                 return -1;
 506                         }
 507                         /* reset checksum & counter */
 508                         checksum=0;
 509                         count=0;
 510                 }
 511
 512         }
 513
 514         return 0;
 515 }
 516
 517 int send_cmd(int sfd,u32 addr,u32 len,u8 cmd) {
 518
 519         int ret,i,cnt,size;
 520         int as,ls;
 521         u8 send[9];
 522
 523         switch(cmd) {
 524                 case CMD_READ:
 525                 case CMD_WRITE:
 526                         as=4;
 527                         ls=4;
 528                         break;
 529                 case CMD_CHIP_ERASE:
 530                         as=0;
 531                         ls=1;
 532                         break;
 533                 default:
 534                         printf("send cmd: cmd '%02x' not supported\n",cmd);
 535                         return -1;
 536         }
 537
 538         size=1+as+ls;
 539         send[0]=cmd;
 540
 541         for(i=0;i<as;i++)
 542                 send[1+i]=(addr>>((as-1-i)*8))&0xff;
 543         for(i=0;i<ls;i++)
 544                 send[1+i+as]=(len>>((ls-1-i)*8))&0xff;
 545
 546         cnt=0;
 547         while(size) {
 548                 ret=write(sfd,send+cnt,size);
 549                 if(ret<0) {
 550                         perror("dump file: send cmd ");
 551                         return ret;
 552                 }
 553                 size-=ret;
 554                 cnt+=ret;
 555         }
 556
 557         return 0;
 558 }
 559
 560 int write_to_flash(t_lpc *lpc,u8 *buf,u32 addr,int len) {
 561
 562         int cnt,ret;
 563         u8 cksml,cksmr;
 564         u8 check;
 565         int i;
 566
 567         /* send cmd */
 568         send_cmd(lpc->sfd,addr+lpc->roff,len,CMD_WRITE);
 569
 570         /* transfer data */
 571         cnt=0;
 572         cksml=0;
 573         while(len) {
 574                 for(i=0;i<2;i++) {
 575                         while(1) {
 576                                 ret=write(lpc->sfd,buf+cnt+i,1);
 577                                 if(ret<0) {
 578                                         perror("transmit flash content (w)");
 579                                         return ret;
 580                                 }
 581                                 if(ret==1)
 582                                         break;
 583                         }
 584                         while(1) {
 585                                 ret=read(lpc->sfd,&check,1);
 586                                 if(ret<0) {
 587                                         perror("transmit flash content (r)");
 588                                         return ret;
 589                                 }
 590                                 if(ret==1)
 591                                         break;
 592                         }
 593                         if(buf[cnt+i]!=check)
 594                                 printf("FATAL: write to flash: wrong transfer\n");
 595                 }
 596                 cksml+=buf[cnt];
 597                 cksml+=buf[cnt+1];
 598                 cnt+=2;
 599                 len-=2;
 600         }
 601
 602         /* check ack */
 603         while(1) {
 604                 ret=read(lpc->sfd,&cksmr,1);
 605                 if(ret<0) {
 606                         perror("write to flash: read cksm");
 607                         return ret;
 608                 }
 609                 if(ret==1) break;
 610         }
 611         if(cksml!=cksmr) {
 612                 printf("FATAL: wrong checksum or failure in flash write!\n");
 613                 if(cksml+1==cksmr)
 614                         printf(" -> most probably due to flash write!");
 615                 else
 616                         printf(" -> most probably due to failure in transfer!");
 617         }
 618
 619         return 0;
 620 }
 621
 622 int firmware_to_mem(t_lpc *lpc,u8 memtype) {
 623
 624         char buf[BUFSIZE];
 625         u32 addr,len,type;
 626         int ret,temp;
 627         int fd;
 628
 629         /* prepare for memory type */
 630         if(memtype==RAM)
 631                 fd=lpc->fwfd;
 632         else if(memtype==FLASH)
 633                 fd=lpc->ffwfd;
 634         else
 635                 return -1;
 636
 637         /* read a line */
 638         ret=1;
 639         while(ret) {
 640                 /* sync line */
 641                 ret=read(fd,buf,1);
 642                 switch(buf[0]) {
 643                         case '\r':
 644                                 continue;
 645                         case '\n':
 646                                 continue;
 647                         case ':':
 648                                 /* start code */
 649                                 break;
 650                         default:
 651                                 printf("fw to mem: no ihex format\n");
 652                                 return -1;
 653                 }
 654                 /* read len */
 655                 ret=read(fd,buf,2);
 656                 sscanf(buf,"%02x",&len);
 657                 /* read addr */
 658                 ret=read(fd,buf,4);
 659                 sscanf(buf,"%04x",&addr);
 660                 /* read type */
 661                 ret=read(fd,buf,2);
 662                 sscanf(buf,"%02x",&type);
 663                 /* successfull return if type is end of file */
 664                 if(type==0x01)
 665                         return 0;
 666                 /* read data (and cksum) */
 667                 ret=read(fd,buf,2*(len+1));
 668                 if(ret!=(2*(len+1))) {
 669                         printf("fw to mem: data missing\n");
 670                                 return -1;
 671                 }
 672                 for(ret=0;ret<len;ret++) {
 673                         sscanf(buf+2*ret,"%02x",&temp);
 674                         buf[ret]=temp;
 675                 }
 676                 /* act according to type */
 677                 switch(type) {
 678                         //case 0x03:
 679                         //      /* get cs and ip */
 680                         //      break;
 681                         case 0x00:
 682                                 if(len%4) {
 683                                         printf("fw to mem: invalid len\n");
 684                                         return -1;
 685                                 }
 686                                 if(memtype==RAM)
 687                                         write_to_ram(lpc,buf,addr,len);
 688                                 else
 689                                         write_to_flash(lpc,(u8 *)buf,addr,len);
 690                                 break;
 691                         case 0x04:
 692                                 lpc->roff=((buf[0]<<24)|(buf[1]<<16));
 693                                 break;
 694                         case 0x05:
 695                                 lpc->jaddr=((buf[0]<<24)|(buf[1]<<16));
 696                                 lpc->jaddr|=((buf[2]<<8)|buf[3]);
 697                                 break;
 698                         default:
 699                                 printf("fw to mem: unknown type %02x\n",type);
 700                                 return -1;
 701                 }
 702         }
 703
 704         return 0;
 705 }
 706
 707 int lpc_txbuf_flush(t_lpc *lpc) {
 708
 709         int i,ret;
 710         u8 buf[16];
 711
 712         ret=1;
 713         printf("flushing lpc tx buffer: ");
 714         while(ret) {
 715                 ret=read(lpc->sfd,buf,16);
 716                 for(i=0;i<ret;i++)
 717                         printf("%02x ",buf[i]);
 718         }
 719         printf("\n");
 720
 721         return 0;
 722 }
 723
 724 int dump_files(int sfd,int dfd,u32 addr,u32 len) {
 725
 726         int ret;
 727         int size;
 728         int cnt;
 729         u8 buf[16];
 730
 731         printf("dumping content (addr=0x%08x, len=0x%08x) ...\n",addr,len);
 732
 733         /* send the cmd */
 734         send_cmd(sfd,addr,len,CMD_READ);
 735
 736         /* receive data and dump it to file */
 737         ret=1;
 738         cnt=0;
 739         printf("  receiving data ...\n");
 740         while(ret) {
 741                 ret=read(sfd,buf,16);
 742                 if(ret<0) {
 743                         perror("dump file: read data");
 744                         return ret;
 745                 }
 746                 size=ret;
 747                 cnt=0;
 748                 while(size) {
 749                         ret=write(dfd,buf+cnt,size-cnt);
 750                         if(ret<0) {
 751                                 perror("dump file: write data");
 752                                 return ret;
 753                         }
 754                         cnt+=ret;
 755                         size-=ret;
 756                 }
 757         }
 758
 759         return 0;
 760 }
 761
 762 int main(int argc,char **argv) {
 763
 764         t_lpc lpc;
 765         int i;
 766         int ret;
 767
 768         /*
 769          * initial ...
 770          */
 771
 772         memset(&lpc,0,sizeof(t_lpc));
 773         strncpy(lpc.freq,CRYSTFREQ,7);
 774         lpc.roff=RAMOFFSET;
 775         lpc.jaddr=RAMOFFSET;
 776
 777         /* parse argv */
 778
 779         for(i=1;i<argc;i++) {
 780
 781                 if(argv[i][0]!='-') {
 782                         usage();
 783                         return -1;
 784                 }
 785
 786                 switch(argv[i][1]) {
 787                         case 'd':
 788                                 strncpy(lpc.sdev,argv[++i],127);
 789                                 break;
 790                         case 'f':
 791                                 strncpy(lpc.fwfile,argv[++i],127);
 792                                 lpc.info|=FIRMWARE;
 793                                 break;
 794                         case 'v':
 795                                 lpc.info|=VERBOSE;
 796                                 break;
 797                         case 'c':
 798                                 strncpy(lpc.freq,argv[++i],7);
 799                                 break;
 800                         case 'D':
 801                                 if(argv[i][2]=='0') {
 802                                         lpc.info|=BANK0;
 803                                         strncpy(lpc.bank0,argv[++i],127);
 804                                         break;
 805                                 }
 806                                 else if(argv[i][2]=='2') {
 807                                         lpc.info|=BANK2;
 808                                         strncpy(lpc.bank2,argv[++i],127);
 809                                         break;
 810                                 }
 811                                 else if(argv[i][2]=='b') {
 812                                         lpc.info|=BL;
 813                                         strncpy(lpc.bl,argv[++i],127);
 814                                         break;
 815                                 }
 816                                 else {
 817                                         usage();
 818                                         return -1;
 819                                 }
 820                         case 'w':
 821                                 strncpy(lpc.ffwfile,argv[++i],127);
 822                                 lpc.info|=FLASHFW;
 823                                 break;
 824                         default:
 825                                 usage();
 826                                 return -1;
 827                 }
 828
 829         }
 830
 831         /* open serial port */
 832         if(open_serial_device(&lpc)<0)
 833                 goto end;
 834
 835         /* boot loader init */
 836         printf("boot loader init ...\n");
 837         if(bl_init(&lpc)<0)
 838                 return -1;
 839
 840         /* quit if there is no hex file to process */
 841         if(!(lpc.info&FIRMWARE)) {
 842                 printf("no firmware -> aborting\n");
 843                 goto end;
 844         }
 845
 846         /* open firmware file */
 847         if(open_firmware(&lpc)<0)
 848                 goto end;
 849
 850         /* open dump files */
 851         if(open_dumpfiles(&lpc)<0)
 852                 goto end;
 853
 854         /* parse intel hex file and write to ram */
 855         printf("write firmware to ram ...\n");
 856         firmware_to_mem(&lpc,RAM);
 857
 858         /* unlock go cmd */
 859         printf("unlock go command ...\n");
 860         unlock_go(&lpc);
 861
 862         /* go! */
 863         printf("go ...\n");
 864         ret=go(&lpc);
 865
 866         /* flush the lpc2220 tx buf */
 867         lpc_txbuf_flush(&lpc);
 868
 869         /* reconfigure the serial port */
 870         if(reconfig_serial_device(&lpc)<0)
 871                 goto end;
 872
 873         /* download flash/bootloader content */
 874         if(lpc.info&BANK0)
 875                 dump_files(lpc.sfd,lpc.b0fd,BANK0_ADDR,BANK_SIZE);
 876         if(lpc.info&BANK2)
 877                 dump_files(lpc.sfd,lpc.b2fd,BANK2_ADDR,BANK_SIZE);
 878         if(lpc.info&BL)
 879                 dump_files(lpc.sfd,lpc.blfd,BL_ADDR,BL_SIZE);
 880
 881         /* write a firmware to the lpc flash */
 882         if(lpc.info&FLASHFW) {
 883                 printf("writing firmware to flash ...\n");
 884                 send_cmd(lpc.sfd,0,'0',CMD_CHIP_ERASE);
 885                 lpc.roff=BANK0_ADDR;
 886                 firmware_to_mem(&lpc,FLASH);
 887         }
 888
 889 end:
 890         if(lpc.sfd)
 891                 close(lpc.sfd);
 892         if(lpc.fwfd)
 893                 close(lpc.fwfd);
 894         if(lpc.b0fd)
 895                 close(lpc.b0fd);
 896         if(lpc.b2fd)
 897                 close(lpc.b2fd);
 898         if(lpc.blfd)
 899                 close(lpc.blfd);
 900         if(lpc.ffwfd)
 901                 close(lpc.ffwfd);
 902
 903         return 0;
 904 }
 905