betty/fwflash.c

   1 /*
   2  * fwflash.c - handling the betty flashes
   3  *
   4  * author: hackbard@hackdaworld.org
   5  *
   6  */
   7
   8 /*
   9  * include files
  10  */
  11
  12 #include <stdio.h>
  13
  14 #include "lpc2xxx.h"
  15
  16 /*
  17  * defines
  18  */
  19
  20 /* bank 0/2 and boootloader addr/size */
  21 #define BANK0                   0x80000000
  22 #define BANK2                   0x82000000
  23 #define BANK_SIZE               0x00100000
  24 #define BOOTLOADER              0x7fffe000
  25 #define BL_SIZE                 0x00002000
  26
  27 /* flash cmd addresses - flash[0-18] <--> arm[1-19]*/
  28 #define B0F555  (*((volatile unsigned short *)(BANK0|0xaaa)))   // 0x555
  29 #define B0F2AA  (*((volatile unsigned short *)(BANK0|0x554)))   // 0x2aa
  30 #define B0F     (*((volatile unsigned short *)(BANK0)))
  31 #define B2F555  (*((volatile unsigned short *)(BANK2|0xaaa)))   // 0x555
  32 #define B2F2AA  (*((volatile unsigned short *)(BANK2|0x554)))   // 0x2aa
  33 #define B2F     (*((volatile unsigned short *)(BANK2)))
  34
  35 /* commands */
  36 #define CMD_READ                'R'
  37 #define CMD_WRITE               'W'
  38 #define CMD_CHIP_ERASE          'E'
  39 #define CMD_SECTOR_ERASE        'S'
  40 #define CMD_CHIP_ID             'I'
  41
  42 #define BUFSIZE                 16
  43
  44 /*
  45  * type definitions
  46  */
  47
  48 typedef unsigned char u8;
  49 typedef unsigned short u16;
  50 typedef unsigned int u32;
  51
  52 /*
  53  * sector addresses
  54  */
  55
  56 unsigned long sector_address[19]={
  57         0x00000,0x02000,0x03000,0x04000,0x08000,
  58         0x10000,0x18000,
  59         0x20000,0x28000,
  60         0x30000,0x38000,
  61         0x40000,0x48000,
  62         0x50000,0x58000,
  63         0x60000,0x68000,
  64         0x70000,0x78000
  65 };
  66
  67 /*
  68  * functions
  69  */
  70
  71 void uart0_send_byte(u8 send);
  72
  73 void mmap_init(u8 memtype) {
  74
  75         MEMMAP=memtype;
  76 }
  77
  78 void pll_init(void) {
  79
  80         /* configuration */
  81         PLLCFG=0x42;    // multiplier = 3 (for cclk), dividor = 4 (for f_cco)
  82         PLLCON=0x03;    // enable and set as clk source for the lpc
  83         /* feed sequence */
  84         PLLFEED=0xaa;
  85         PLLFEED=0x55;
  86         /* wait for lock */
  87         while(!(PLLSTAT&(1<<10)))
  88                 continue;
  89 }
  90
  91 void ext_mem_bank_init(void) {
  92
  93         BCFG0=0x10000420;       // flash 1
  94         BCFG1=0x00000c42;       // lcd
  95         BCFG2=0x10000420;       // flash 2
  96 }
  97
  98 void pin_select_init() {
  99
 100         /*
 101          * a[19:2] -> address lines
 102          */
 103
 104         PINSEL2=0x0d6041d4;
 105 }
 106
 107 void uart0_init(void) {
 108
 109         PINSEL0=0x05;                   // pin select -> tx, rx
 110         UART0_FCR=0x07;                 // enable fifo
 111         UART0_LCR=0x83;                 // set dlab + word length
 112         UART0_DLL=0x04;                 // br: 38400 @ 10/4 mhz
 113         UART0_DLM=0x00;
 114         UART0_LCR=0x03;                 // unset dlab
 115 }
 116
 117 void uart0_send_string(char *txbuf) {
 118
 119         int i;
 120
 121         i=0;
 122
 123         while(txbuf[i]) {
 124                 UART0_THR=txbuf[i++];
 125                 /* flush if tx buffer maximum reached */
 126                 if(!(i%16))
 127                         while(!(UART0_LSR&(1<<6)))
 128                                 continue;
 129         }
 130
 131         /* flush if \n and \r do not fit in the tx buffer */
 132         if(i>14)
 133                 while(!(UART0_LSR&(1<<6)))
 134                         continue;
 135
 136         UART0_THR='\n';
 137         UART0_THR='\r';
 138
 139         /* flush uart0 anyways */
 140         while(!(UART0_LSR&(1<<6)))
 141                 continue;
 142 }
 143
 144 void uart0_send_buf16(u16 *buf,int len) {
 145
 146         int i;
 147
 148         i=0;
 149
 150         for(i=0;i<len/2;i++) {
 151                 if(!(i%8))
 152                         while(!(UART0_LSR&(1<<6)))
 153                                 continue;
 154                 UART0_THR=buf[i]&0xff;
 155                 UART0_THR=(buf[i]>>8)&0xff;
 156         }
 157 }
 158
 159 void uart0_send_buf32(u32 *buf,int len) {
 160
 161         int i;
 162
 163         i=0;
 164
 165         for(i=0;i<len/4;i++) {
 166                 if(!(i%4))
 167                         while(!(UART0_LSR&(1<<6)))
 168                                 continue;
 169                 UART0_THR=buf[i]&0xff;
 170                 UART0_THR=(buf[i]>>8)&0xff;
 171                 UART0_THR=(buf[i]>>16)&0xff;
 172                 UART0_THR=(buf[i]>>24)&0xff;
 173         }
 174 }
 175
 176 void uart0_send_byte(u8 send) {
 177
 178         while(!(UART0_LSR&(1<<5)))
 179                 continue;
 180
 181         UART0_THR=send;
 182 }
 183
 184 u8 uart0_get_byte(void) {
 185
 186         u8 rx;
 187
 188         while(!(UART0_LSR&(1<<0)))
 189                 continue;
 190
 191         rx=UART0_RBR;
 192
 193         return rx;
 194 }
 195
 196 void flash_reset(u8 bank) {
 197
 198         if((bank!='0')&(bank!='2'))
 199                 return;
 200
 201         if(bank=='0')
 202                 B0F=0xf0;
 203         else
 204                 B2F=0xf0;
 205 }
 206
 207 void flash_sector_erase(u8 flash,u8 sector) {
 208
 209         u32 a18_12;
 210         u32 base;
 211
 212         if(sector>18)
 213                 return;
 214         a18_12=sector_address[sector]<<1;
 215
 216         if((flash!='0')&(flash!='2'))
 217                 return;
 218
 219         switch(flash) {
 220                 case '0':
 221                         base=0x80000000;
 222                         B0F555=0xaa;
 223                         B0F2AA=0x55;
 224                         B0F555=0x80;
 225                         B0F555=0xaa;
 226                         B0F2AA=0x55;
 227                         *((volatile u16 *)(base|a18_12))=0x30;
 228                         break;
 229                 case '2':
 230                         base=0x82000000;
 231                         B2F555=0xaa;
 232                         B2F2AA=0x55;
 233                         B2F555=0x80;
 234                         B2F555=0xaa;
 235                         B2F2AA=0x55;
 236                         *((volatile u16 *)(base|a18_12))=0x30;
 237                         break;
 238                 default:
 239                         return;
 240         }
 241
 242         return;
 243 }
 244
 245 void flash_chip_erase(u8 bank) {
 246
 247         u8 status;
 248
 249         if((bank!='0')&(bank!='2'))
 250                 return;
 251
 252         if(bank=='0') {
 253                 B0F555=0xaa;
 254                 B0F2AA=0x55;
 255                 B0F555=0x80;
 256                 B0F555=0xaa;
 257                 B0F2AA=0x55;
 258                 B0F555=0x10;
 259         }
 260         else {
 261                 B2F555=0xaa;
 262                 B2F2AA=0x55;
 263                 B2F555=0x80;
 264                 B2F555=0xaa;
 265                 B2F2AA=0x55;
 266                 B2F555=0x10;
 267         }
 268
 269         while(1) {
 270                 if(bank=='0')
 271                         status=B0F;
 272                 else
 273                         status=B2F;
 274
 275                 if(status&0x80) {
 276                         /* send an ack */
 277                         uart0_send_byte(status);
 278                         break;
 279                 }
 280         }
 281 }
 282
 283 void unlock_bypass(u8 bank) {
 284
 285         if((bank!='0')&(bank!='2'))
 286                 return;
 287
 288         if(bank=='0') {
 289                 B0F555=0xaa;
 290                 B0F2AA=0x55;
 291                 B0F555=0x20;
 292         }
 293         else {
 294                 B2F555=0xaa;
 295                 B2F2AA=0x55;
 296                 B2F555=0x20;
 297         }
 298 }
 299
 300 void unlock_bypass_reset(u8 bank) {
 301
 302         if((bank!='0')&(bank!='2'))
 303                 return;
 304
 305         if(bank=='0') {
 306                 B0F=0x90;
 307                 B0F=0x00;
 308         }
 309         else {
 310                 B2F=0x90;
 311                 B2F=0x00;
 312         }
 313 }
 314
 315 int flash_write(u32 addr,u16 data) {
 316
 317         u16 check;
 318
 319         if(data==0xffff)
 320                 return 0;
 321
 322         *((unsigned volatile short *)addr)=0xa0;
 323         *((unsigned volatile short *)addr)=data;
 324         while(1) {
 325                 check=*((unsigned short *)addr);
 326                 if((data&0x80)==(check&0x80))
 327                         break;
 328         }
 329         if(data!=check)
 330                 return -1;
 331
 332         return 0;
 333 }
 334
 335 int receive_data_and_write_to_flash(u32 addr,u32 datalen) {
 336
 337         u8 bank;
 338         u32 i,ret;
 339         u16 data;
 340         u8 cksm;
 341         u8 byte;
 342
 343         /* which bank to program */
 344         if(addr<0x82000000)
 345                 bank='0';
 346         else
 347                 bank='2';
 348
 349         /* unlock bypass */
 350         unlock_bypass(bank);
 351
 352         /* receive and write data */
 353         cksm=0;
 354         ret=0;
 355         for(i=0;i<datalen/2;i++) {
 356                 byte=uart0_get_byte();
 357                 data=byte;
 358                 cksm+=byte;
 359                 byte=uart0_get_byte();
 360                 cksm+=byte;
 361                 data|=byte<<8;
 362                 if(flash_write(addr,data)<0)
 363                         ret=-1;
 364                 addr+=2;
 365         }
 366
 367         /* relock bypass */
 368         unlock_bypass_reset(bank);
 369
 370         /* modify cksm on purpose, so the user knows ... */
 371         if(ret==-1)
 372                 cksm+=1;
 373
 374         /* send the cksm */
 375         uart0_send_byte(cksm);
 376
 377         return ret;
 378 }
 379
 380 /*
 381  * main function
 382  */
 383
 384 int main(void) {
 385
 386         /* variables */
 387
 388         u32 i,addrlen,datalen,addr;
 389         u8 buf[BUFSIZE];
 390         u16 data;
 391         u8 cmd;
 392         u8 txrx;
 393
 394         /* memory mapping of interrupt vectors to static ram */
 395
 396         //mmap_init(MMAP_RAM);
 397
 398         /* pll initialization */
 399         pll_init();
 400
 401         /* uart initialization */
 402         uart0_init();
 403
 404         /* external memory init */
 405         ext_mem_bank_init();
 406
 407         /* pin select init */
 408         pin_select_init();
 409
 410         /* begin the main loop */
 411         while(1) {
 412
 413         /* receive cmd */
 414         while(1) {
 415
 416                 cmd=uart0_get_byte();
 417                 txrx=1;
 418                 switch(cmd) {
 419                         case CMD_CHIP_ERASE:
 420                                 addrlen=0;
 421                                 datalen=1;
 422                                 break;
 423                         case CMD_SECTOR_ERASE:
 424                                 addrlen=0;
 425                                 datalen=2;
 426                                 break;
 427                         case CMD_READ:
 428                                 addrlen=4;
 429                                 datalen=4;
 430                         case CMD_WRITE:
 431                                 addrlen=4;
 432                                 datalen=4;
 433                                 break;
 434                         case CMD_CHIP_ID:
 435                                 addrlen=0;
 436                                 datalen=1;
 437                                 break;
 438                         default:
 439                                 txrx=0;
 440                                 break;
 441                 }
 442
 443                 if(txrx)
 444                         break;
 445         }
 446
 447         /* receive (only if there is) more data from uart0 */
 448         addr=0;
 449         for(i=0;i<addrlen;i++) {
 450                 txrx=uart0_get_byte();
 451                 addr|=(txrx<<((addrlen-i-1)*8));
 452         }
 453
 454         for(i=0;i<datalen;i++)
 455                 buf[i]=uart0_get_byte();
 456
 457         /* process the cmd */
 458         switch(cmd) {
 459                 case CMD_SECTOR_ERASE:
 460                         flash_sector_erase(buf[0],buf[1]);
 461                         break;
 462                 case CMD_READ:
 463                         /* data length to read */
 464                         datalen=buf[0]<<24|buf[1]<<16|buf[2]<<8|buf[3];
 465                         /* check addr and datalen */
 466                         if((addr>=BANK0)&(addr+datalen<=BANK0+BANK_SIZE))
 467                                 uart0_send_buf16((u16 *)addr,datalen);
 468                         if((addr>=BANK2)&(addr+datalen<=BANK2+BANK_SIZE))
 469                                 uart0_send_buf16((u16 *)addr,datalen);
 470                         if((addr>=BOOTLOADER)&
 471                            (addr+datalen<BOOTLOADER-1+BL_SIZE))
 472                                 uart0_send_buf32((u32 *)addr,datalen);
 473                         break;
 474                 case CMD_WRITE:
 475                         /* data length */
 476                         datalen=buf[0]<<24|buf[1]<<16|buf[2]<<8|buf[3];
 477                         /* check addr and data len */
 478                         if(((addr>=BANK0)&(addr+datalen<=BANK0+BANK_SIZE))|
 479                            ((addr>=BANK2)&(addr+datalen<=BANK2+BANK_SIZE)))
 480                                 receive_data_and_write_to_flash(addr,datalen);
 481                         break;
 482                 case CMD_CHIP_ERASE:
 483                         flash_chip_erase(buf[0]);
 484                         break;
 485                 case CMD_CHIP_ID:
 486                         if(buf[0]=='0') {
 487                                 B0F555=0xaa;
 488                                 B0F2AA=0x55;
 489                                 B0F555=0x90;
 490                                 data=*((u16 *)BANK0);
 491                                 uart0_send_buf16(&data,2);
 492                                 data=*((u16 *)(BANK0|0x200));
 493                                 uart0_send_buf16(&data,2);
 494                         }
 495                         else if(buf[0]=='2') {
 496                                 B2F555=0xaa;
 497                                 B2F2AA=0x55;
 498                                 B2F555=0x90;
 499                                 data=*((u16 *)BANK2);
 500                                 uart0_send_buf16(&data,2);
 501                                 data=*((u16 *)(BANK2|0x200));
 502                                 uart0_send_buf16(&data,2);
 503                         }
 504                         break;
 505                 default:
 506                         break;
 507         }
 508
 509         }
 510
 511         return 0;
 512 }
 513