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                 0x00000800
  26
  27 /* flash cmd addresses - flash[0-18] <--> arm[1-19]*/
  28 #define B0F555  (*((volatile unsigned long *)(BANK0|0xaaa)))    // 0x555
  29 #define B0F2AA  (*((volatile unsigned long *)(BANK0|0x554)))    // 0x2aa
  30 #define B2F555  (*((volatile unsigned long *)(BANK2|0xaaa)))    // 0x555
  31 #define B2F2AA  (*((volatile unsigned long *)(BANK2|0x554)))    // 0x2aa
  32
  33 /* commands */
  34 #define CMD_READ                'R'
  35 #define CMD_CHIP_ERASE          'E'
  36 #define CMD_CHIP_ID             'I'
  37
  38 #define BUFSIZE                 16
  39
  40 /*
  41  * type definitions
  42  */
  43
  44 typedef unsigned char u8;
  45 typedef unsigned short u16;
  46 typedef unsigned int u32;
  47
  48 /*
  49  * functions
  50  */
  51
  52 void mmap_init(u8 memtype) {
  53
  54         MEMMAP=memtype;
  55 }
  56
  57 void uart0_init(void) {
  58
  59         PINSEL0=0x05;                   // pin select -> tx, rx
  60         UART0_FCR=0x07;                 // enable fifo
  61         UART0_LCR=0x83;                 // set dlab + word length
  62         //UART0_DLL=0x10;                       // br: 9600 @ 10/4 mhz
  63         UART0_DLL=0x04;                 // br: 38400 @ 10/4 mhz
  64         UART0_DLM=0x00;
  65         UART0_LCR=0x03;                 // unset dlab
  66 }
  67
  68 void uart0_send_string(char *txbuf) {
  69
  70         int i;
  71
  72         i=0;
  73
  74         while(txbuf[i]) {
  75                 UART0_THR=txbuf[i++];
  76                 /* flush if tx buffer maximum reached */
  77                 if(!(i%16))
  78                         while(!(UART0_LSR&(1<<6)))
  79                                 continue;
  80         }
  81
  82         /* flush if \n and \r do not fit in the tx buffer */
  83         if(i>14)
  84                 while(!(UART0_LSR&(1<<6)))
  85                         continue;
  86
  87         UART0_THR='\n';
  88         UART0_THR='\r';
  89
  90         /* flush uart0 anyways */
  91         while(!(UART0_LSR&(1<<6)))
  92                 continue;
  93 }
  94
  95 void uart0_send_buf16(u16 *buf,int len) {
  96
  97         int i;
  98
  99         i=0;
 100
 101         for(i=0;i<len/2;i++) {
 102                 if(!(i%8))
 103                         while(!(UART0_LSR&(1<<6)))
 104                                 continue;
 105                 UART0_THR=buf[i]&0xff;
 106                 UART0_THR=(buf[i]>>8)&0xff;
 107         }
 108 }
 109
 110 void uart0_send_buf32(u32 *buf,int len) {
 111
 112         int i;
 113
 114         i=0;
 115
 116         for(i=0;i<len/4;i++) {
 117                 if(!(i%4))
 118                         while(!(UART0_LSR&(1<<6)))
 119                                 continue;
 120                 UART0_THR=buf[i]&0xff;
 121                 UART0_THR=(buf[i]>>8)&0xff;
 122                 UART0_THR=(buf[i]>>16)&0xff;
 123                 UART0_THR=(buf[i]>>24)&0xff;
 124         }
 125 }
 126
 127 void uart0_send_byte(u8 send) {
 128
 129         while(!(UART0_LSR&(1<<5)))
 130                 continue;
 131
 132         UART0_THR=send;
 133 }
 134
 135 u8 uart0_get_byte(void) {
 136
 137         u8 rx;
 138
 139         while(!(UART0_LSR&(1<<0)))
 140                 continue;
 141
 142         rx=UART0_RBR;
 143
 144         return rx;
 145 }
 146
 147 /*
 148  * main function
 149  */
 150
 151 int main(void) {
 152
 153         /* variables */
 154
 155         u32 i,addrlen,datalen,addr;
 156         u8 buf[BUFSIZE];
 157         u16 data;
 158         u8 cmd;
 159         u8 txrx;
 160
 161         /* memory mapping of interrupt vectors to static ram */
 162
 163         //mmap_init(MMAP_RAM);
 164
 165         /* uart initialization */
 166         uart0_init();
 167
 168         /* external memory init */
 169         BCFG0=0x1000FBEF;               // BCFG2 should be fine as is
 170
 171         /* begin the main loop */
 172         while(1) {
 173
 174         /* receive cmd */
 175         while(1) {
 176
 177                 cmd=uart0_get_byte();
 178                 txrx=1;
 179                 switch(cmd) {
 180                         case CMD_CHIP_ERASE:
 181                                 addrlen=0;
 182                                 datalen=1;
 183                                 break;
 184                         case CMD_READ:
 185                                 addrlen=4;
 186                                 datalen=4;
 187                                 break;
 188                         case CMD_CHIP_ID:
 189                                 addrlen=0;
 190                                 datalen=1;
 191                                 break;
 192                         default:
 193                                 txrx=0;
 194                                 break;
 195                 }
 196
 197                 if(txrx)
 198                         break;
 199         }
 200
 201         /* receive (only if there is) more data from uart0 */
 202         addr=0;
 203         for(i=0;i<addrlen;i++) {
 204                 txrx=uart0_get_byte();
 205                 addr|=(txrx<<((addrlen-i-1)*8));
 206         }
 207
 208         for(i=0;i<datalen;i++)
 209                 buf[i]=uart0_get_byte();
 210
 211         /* process the cmd */
 212         switch(cmd) {
 213                 case CMD_READ:
 214                         /* data length to read */
 215                         datalen=buf[0]<<24|buf[1]<<16|buf[2]<<8|buf[3];
 216                         /* check addr and datalen */
 217                         if((addr>=BANK0)&(addr+datalen<=BANK0+BANK_SIZE))
 218                                 uart0_send_buf16((u16 *)addr,datalen);
 219                         if((addr>=BANK2)&(addr+datalen<=BANK2+BANK_SIZE))
 220                                 uart0_send_buf16((u16 *)addr,datalen);
 221                         if((addr>=BOOTLOADER)&(addr+datalen<=BOOTLOADER+BL_SIZE))
 222                                 uart0_send_buf32((u32 *)addr,datalen);
 223                         break;
 224                 case CMD_CHIP_ERASE:
 225                         if(buf[0]=='0') {
 226                                 B0F555=0xaa;
 227                                 B0F2AA=0x55;
 228                                 B0F555=0x80;
 229                                 B0F555=0xaa;
 230                                 B0F2AA=0x55;
 231                                 B0F555=0x10;
 232                         }
 233                         else if(buf[0]=='2') {
 234                                 B2F555=0xaa;
 235                                 B2F2AA=0x55;
 236                                 B2F555=0x80;
 237                                 B2F555=0xaa;
 238                                 B2F2AA=0x55;
 239                                 B2F555=0x10;
 240                         }
 241                         uart0_send_byte(buf[0]);
 242                         break;
 243                 case CMD_CHIP_ID:
 244                         if(buf[0]=='0') {
 245                                 B0F555=0xaa;
 246                                 B0F2AA=0x55;
 247                                 B0F555=0x90;
 248                                 data=*((u16 *)BANK0);
 249                                 data=*((u16 *)(BANK0|0x200));
 250                         }
 251                         else if(buf[0]=='2') {
 252                                 B2F555=0xaa;
 253                                 B2F2AA=0x55;
 254                                 B2F555=0x90;
 255                                 data=*((u16 *)BANK2);
 256                                 data=*((u16 *)(BANK2|0x200));
 257                         }
 258                         uart0_send_buf16(&data,2);
 259                         break;
 260                 default:
 261                         break;
 262         }
 263
 264         }
 265
 266         return 0;
 267 }
 268