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 addr */
  21 #define BANK0                   0x80000000
  22 #define BANK2                   0x82000000
  23
  24 /* flash cmd addresses */
  25 #define B0F555  (*((volatile unsigned long *)(BANK0|0x555)))
  26 #define B0F2AA  (*((volatile unsigned long *)(BANK0|0x2aa)))
  27 #define B2F555  (*((volatile unsigned long *)(BANK2|0x555)))
  28 #define B2F2AA  (*((volatile unsigned long *)(BANK2|0x2aa)))
  29
  30 /* commands */
  31 #define CMD_READ                'R'
  32 #define CMD_CHIP_ERASE          'E'
  33
  34 #define BUFSIZE                 16
  35
  36 /*
  37  * type definitions
  38  */
  39
  40 typedef unsigned char u8;
  41 typedef unsigned short u16;
  42 typedef unsigned int u32;
  43
  44 /*
  45  * define macros
  46  */
  47
  48 #define TX_BYTE(x)              while(!(UART0_LSR&(1<<5))) continue; \
  49                                 UART0_THR=x
  50
  51 #define TX_NL                   TX_BYTE('\n'); TX_BYTE('\r')
  52
  53 #define TX_STRING(x,len)        for(scnt=0;scnt<len;scnt++) {   \
  54                                         TX_BYTE(x[scnt]);       \
  55                                 }                               \
  56                                 TX_NL
  57
  58 /*
  59  * function prototypes
  60  */
  61
  62 void mmap_init(u8 memtype);
  63 void uart0_init(void);
  64 void uart0_send_string(char *txbuf);
  65 void uart0_send_char(char send);
  66
  67 /*
  68  * global variables
  69  */
  70
  71 int scnt;
  72
  73 /*
  74  * main function
  75  */
  76
  77 int main(void) {
  78
  79         /* variables */
  80
  81         u32 i,addrlen,datalen;
  82         u8 buf[BUFSIZE];
  83         u32 addr;
  84         u16 *dptr;
  85         u8 cmd;
  86         u8 txrx;
  87
  88         /* memory mapping of interrupt vectors to static ram */
  89
  90         //mmap_init(MMAP_RAM);
  91
  92         /* uart initialization */
  93
  94         //uart0_init();
  95
  96         PINSEL0=0x05;                   // pin select -> tx, rx
  97         UART0_FCR=0x07;                 // enable fifo
  98         UART0_LCR=0x83;                 // set dlab + word length
  99         UART0_DLL=0x10;                 // br: 9600 @ 10/4 mhz
 100         UART0_DLM=0x00;
 101         UART0_LCR=0x03;                 // unset dlab
 102
 103         /* external memory init */
 104
 105         BCFG0=0x1000FBEF;               // BCFG2 should be fine as is
 106
 107         /* begin the main loop */
 108         while(1) {
 109
 110         /* receive cmd */
 111         while(1) {
 112
 113                 while(!(UART0_LSR&(1<<0)))
 114                         continue;
 115                 cmd=UART0_RBR;
 116
 117                 if(cmd==CMD_CHIP_ERASE) {
 118                         addrlen=0;
 119                         datalen=1;
 120                         break;
 121                 }
 122
 123                 if(cmd==CMD_READ) {
 124                         addrlen=4;
 125                         datalen=1;
 126                         break;
 127                 }
 128         }
 129
 130         /* receive (only if there is) more data from uart0 */
 131
 132         addr=0;
 133         for(i=0;i<addrlen;i++) {
 134                 //TX_STRING("got addr",8);
 135                 while(!(UART0_LSR&(1<<0)))
 136                         continue;
 137                 txrx=UART0_RBR;
 138                 //addr|=(txrx<<((addrlen-i-1)*4));
 139                 addr=0x80000000;
 140         }
 141
 142         for(i=0;i<datalen;i++) {
 143                 //TX_STRING("got data",8);
 144                 while(!(UART0_LSR&(1<<0)))
 145                         continue;
 146                 buf[i]=UART0_RBR;
 147         }
 148
 149         /* process the cmd */
 150
 151         switch(cmd) {
 152                 case CMD_READ:
 153                         dptr=(u16 *)addr;
 154                         for(i=0;i<buf[0];i++) {
 155                                 TX_BYTE(*dptr);
 156                                 dptr++;
 157                         }
 158                         break;
 159                 case CMD_CHIP_ERASE:
 160                         if(buf[0]=='0') {
 161                                 B0F555=0xaa;
 162                                 B0F2AA=0x55;
 163                                 B0F555=0x80;
 164                                 B0F555=0xaa;
 165                                 B0F2AA=0x55;
 166                                 B0F555=0x10;
 167                         }
 168                         else if(buf[0]=='2') {
 169                                 B2F555=0xaa;
 170                                 B2F2AA=0x55;
 171                                 B2F555=0x80;
 172                                 B2F555=0xaa;
 173                                 B2F2AA=0x55;
 174                                 B2F555=0x10;
 175                         }
 176                         break;
 177                 default:
 178                         break;
 179         }
 180
 181         /* send an ack, the cmd! */
 182         TX_BYTE(cmd);
 183
 184         }
 185
 186         return 0;
 187 }
 188
 189 /*
 190  * functions
 191  */
 192
 193 void mmap_init(u8 memtype) {
 194
 195         MEMMAP=memtype;
 196 }
 197
 198 void uart0_init(void) {
 199
 200         PINSEL0=0x05;                   // pin select -> tx, rx
 201         UART0_FCR=0x07;                 // enable fifo
 202         UART0_LCR=0x83;                 // set dlab + word length
 203         UART0_DLL=0x10;                 // br: 9600 @ 10/4 mhz
 204         UART0_DLM=0x00;
 205         UART0_LCR=0x03;                 // unset dlab
 206 }
 207
 208 void uart0_send_string(char *txbuf) {
 209
 210         int i;
 211
 212         i=0;
 213
 214         while(txbuf[i])
 215                 UART0_THR=txbuf[i++];
 216         UART0_THR='\n';
 217         UART0_THR='\r';
 218
 219         while(!(UART0_LSR&(1<<6))) {}
 220 }
 221
 222 void uart0_send_char(char send) {
 223
 224         while(!(UART0_LSR&(1<<5)))
 225                 continue;
 226
 227         UART0_THR=send;
 228 }
 229