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