Code policed (removed tab chars, no C++ comments, line length); all register manipulation hex values match register width. No code change.

git-svn-id: svn://svn.rockbox.org/rockbox/trunk@5478 a1c6a512-1295-4272-9138-f99709370657

1 files changed, 375 insertions, 369 deletions

diff --git a/flash/bootloader/bootloader.c b/flash/bootloader/bootloader.c
index e5bab34abd..370ac5bee5 100644
--- a/flash/bootloader/bootloader.c
+++ b/flash/bootloader/bootloader.c
@@ -7,8 +7,8 @@
  *                     \/            \/     \/    \/            \/
  * $Id$
  *
- * Copyright (C) 2003 by Jörg Hohensohn 
- * 
+ * Copyright (C) 2003 by Jörg Hohensohn
+ *
  * Second-level bootloader, with dual-boot feature by holding F1/Menu
  * This is the image being descrambled and executed by the boot ROM.
  * It's task is to copy Rockbox from Flash to DRAM.
@@ -27,266 +27,268 @@
 
 
 #ifdef NO_ROM
-// start with the vector table
-UINT32 vectors[] __attribute__ ((section (".vectors"))) = 
+/* start with the vector table */
+UINT32 vectors[] __attribute__ ((section (".vectors"))) =
 {
-        (UINT32)_main, // entry point, the copy routine
-        (UINT32)(end_stack - 1), // initial stack pointer
-        FLASH_BASE + 0x200, // source of image in flash
-        (UINT32)total_size, // size of image
-        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-        0x03020080 // mask and version (just as a suggestion)
+    (UINT32)_main,           /* entry point, the copy routine */
+    (UINT32)(end_stack - 1), /* initial stack pointer */
+    FLASH_BASE + 0x200,      /* source of image in flash */
+    (UINT32)total_size,      /* size of image */
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+    0x03020080 /* mask and version (just as a suggestion) */
 };
 #else
-// our binary has to start with a vector to the entry point
+/* our binary has to start with a vector to the entry point */
 tpMain start_vector[] __attribute__ ((section (".startvector"))) = {main};
 #endif
 
-#ifdef NO_ROM // some code which is only needed for the romless variant
+#ifdef NO_ROM /* some code which is only needed for the romless variant */
 void _main(void)
 {
-        UINT32* pSrc;
-        UINT32* pDest;
-        UINT32* pEnd;
+    UINT32* pSrc;
+    UINT32* pDest;
+    UINT32* pEnd;
 /*
-        asm volatile ("ldc %0,sr" : : "r"(0xF0)); // disable interrupts
-        asm volatile ("mov.l @%0,r15" : : "r"(4)); // load stack
-        asm volatile ("ldc %0,vbr" : : "r"(0)); // load vector base
+    asm volatile ("ldc %0,sr" : : "r"(0xF0)); // disable interrupts
+    asm volatile ("mov.l @%0,r15" : : "r"(4)); // load stack
+    asm volatile ("ldc %0,vbr" : : "r"(0)); // load vector base
 */
-        // copy everything to IRAM and continue there
-        pSrc = begin_iramcopy;
-        pDest = begin_text;
-        pEnd = pDest + (begin_stack - begin_text);
-
-        do
-        {
-                *pDest++ = *pSrc++;
-        }
-        while (pDest < pEnd);
-
-        main(); // jump to the real main()
+    /* copy everything to IRAM and continue there */
+    pSrc = begin_iramcopy;
+    pDest = begin_text;
+    pEnd = pDest + (begin_stack - begin_text);
+
+    do
+    {
+        *pDest++ = *pSrc++;
+    }
+    while (pDest < pEnd);
+
+    main(); /* jump to the real main() */
 }
 
 
 void BootInit(void)
 {
-        // inits from the boot ROM, whether they make sense or not
-        PBDR &= 0xFFBF; // LED off (0x131E)
-        PBCR2 = 0; // all GPIO
-        PBIOR |= 0x40; // LED output
-        PBIOR &= 0xFFF1; // LCD lines input
-
-        // init DRAM like the boot ROM does
-        PACR2 &= 0xFFFB;
-        PACR2 |= 0x0008;
-        CASCR  = 0xAF;
-        BCR   |= 0x8000;
-        WCR1  &= 0xFDFD;
-        DCR    = 0x0E00;
-        RCR    = 0x5AB0;
-        RTCOR  = 0x9605;
-        RTCSR  = 0xA518;
+    /* inits from the boot ROM, whether they make sense or not */
+    PBDR  &= 0xFFBF; /* LED off (0x131E) */
+    PBCR2  = 0;      /* all GPIO */
+    PBIOR |= 0x0040; /* LED output */
+    PBIOR &= 0xFFF1; /* LCD lines input */
+
+    /* init DRAM like the boot ROM does */
+    PACR2 &= 0xFFFB;
+    PACR2 |= 0x0008;
+    CASCR  = 0xAF;
+    BCR   |= 0x8000;
+    WCR1  &= 0xFDFD;
+    DCR    = 0x0E00;
+    RCR    = 0x5AB0;
+    RTCOR  = 0x9605;
+    RTCSR  = 0xA518;
 }
-#endif // #ifdef NO_ROM
+#endif /* #ifdef NO_ROM */
 
 
 int main(void)
 {
-        int nButton;
+    int nButton;
 
-        PlatformInit(); // model-specific inits
+    PlatformInit(); /* model-specific inits */
 
-        nButton = ButtonPressed();
+    nButton = ButtonPressed();
 
-        if (nButton == 3)
-        {       // F3 means start monitor
-                MiniMon();
-        }
-        else
-        {
-                tImage* pImage;
-                pImage = GetStartImage(nButton); // which image
-                DecompressStart(pImage); // move into place and start it
-        }
+    if (nButton == 3)
+    {   /* F3 means start monitor */
+        MiniMon();
+    }
+    else
+    {
+        tImage* pImage;
+        pImage = GetStartImage(nButton); /* which image */
+        DecompressStart(pImage); /* move into place and start it */
+    }
 
-        return 0; // I guess we won't return  ;-)
+    return 0; /* I guess we won't return  ;-) */
 }
 
 
-// init code that is specific to certain platform
+/* init code that is specific to certain platform */
 void PlatformInit(void)
 {
 #ifdef NO_ROM
-        BootInit(); // if not started by boot ROM, we need to init what it did
+    BootInit(); /* if not started by boot ROM, we need to init what it did */
 #endif
 
 #if defined PLATFORM_PLAYER
-        BRR1  =  0x0019; // 14400 Baud for monitor
-        PACR2 &= 0xFFFC; // GPIO for PA0 (charger detection, input by default)
-        if (FW_VERSION > 451 && (PADRL & 0x01)) 
-        {   // "new" Player and charger not plugged?
-                PBDR |= 0x10; // set PB4 to 1 to power-up the harddisk early
-                PBIOR |= 0x10; // make PB4 an output
-        }
+    BRR1   = 0x19;   /* 14400 Baud for monitor */
+    PACR2 &= 0xFFFC; /* GPIO for PA0 (charger detection, input by default) */
+    if (FW_VERSION > 451 && (PADRL & 0x01))
+    {   /* "new" Player and charger not plugged? */
+        PBDR  |= 0x0010; /* set PB4 to 1 to power-up the harddisk early */
+        PBIOR |= 0x0010; /* make PB4 an output */
+    }
 #elif defined PLATFORM_RECORDER
-        BRR1  =  0x0002; // 115200 Baud for monitor
-        if (ReadADC(7) > 0x100) // charger plugged?
-        {       // switch off the HD, else a flat battery may not start
-                PACR2 &= 0xFBFF; // GPIO for PA5
-                PAIOR |= 0x20;   // make PA5 an output (low by default)
-        }
+    BRR1 = 0x02;     /* 115200 Baud for monitor */
+    if (ReadADC(7) > 0x100) /* charger plugged? */
+    {   /* switch off the HD, else a flat battery may not start */
+        PACR2 &= 0xFBFF; /* GPIO for PA5 */
+        PAIOR |= 0x0020; /* make PA5 an output (low by default) */
+    }
 #elif defined PLATFORM_FM
-        BRR1  =  0x0002; // 115200 Baud for monitor
-        PBDR |= 0x20; // set PB5 to keep power (fixes the ON-holding problem)
-        PBIOR |= 0x20; // make PB5 an output
-        if (ReadADC(0) < 0x1FF) // charger plugged?
-        {       // switch off the HD, else a flat battery may not start
-                PACR2 &= 0xFBFF; // GPIO for PA5
-                PAIOR |= 0x20;   // make PA5 an output (low by default)
-        }
+    BRR1   = 0x02;   /* 115200 Baud for monitor */
+    PBDR  |= 0x0020; /* set PB5 to keep power (fixes the ON-holding problem) */
+    PBIOR |= 0x0020; /* make PB5 an output */
+    if (ReadADC(0) < 0x1FF) /* charger plugged? */
+    {   /* switch off the HD, else a flat battery may not start */
+        PACR2 &= 0xFBFF; /* GPIO for PA5 */
+        PAIOR |= 0x0020; /* make PA5 an output (low by default) */
+    }
 #elif defined PLATFORM_ONDIO
-        BRR1  =  0x0019; // 14400 Baud for monitor
-        PBDR |= 0x20; // set PB5 to keep power (fixes the ON-holding problem)
-        PBIOR |= 0x20; // make PB5 an output
+    BRR1   = 0x19;   /* 14400 Baud for monitor */
+    PBDR  |= 0x0020; /* set PB5 to keep power (fixes the ON-holding problem) */
+    PBIOR |= 0x0020; /* make PB5 an output */
 #endif
 
-        // platform-independent inits
-        DCR |= 0x1000; // enable burst mode on DRAM
-        BCR |= 0x2000; // activate Warp mode (simultaneous internal and external mem access)
+    /* platform-independent inits */
+    DCR |= 0x1000; /* enable burst mode on DRAM */
+    BCR |= 0x2000; /* activate Warp mode (simultaneous internal and external
+                    * mem access) */
 }
 
 
-// Thinned out version of the UCL 2e decompression sourcecode
-// Original (C) Markus F.X.J Oberhumer under GNU GPL license
+/* Thinned out version of the UCL 2e decompression sourcecode
+ * Original (C) Markus F.X.J Oberhumer under GNU GPL license */
 #define GETBIT(bb, src, ilen) \
-        (((bb = bb & 0x7f ? bb*2 : ((unsigned)src[ilen++]*2+1)) >> 8) & 1) 
+    (((bb = bb & 0x7f ? bb*2 : ((unsigned)src[ilen++]*2+1)) >> 8) & 1)
 
 int ucl_nrv2e_decompress_8(
-        const UINT8 *src, UINT8 *dst, UINT32* dst_len)
-{ 
-        UINT32 bb = 0;
-        unsigned ilen = 0, olen = 0, last_m_off = 1;
-
-        for (;;)
-        {
-                unsigned m_off, m_len;
-
-                while (GETBIT(bb,src,ilen))
-                {
-                        dst[olen++] = src[ilen++];
-                }
-                m_off = 1;
-                for (;;)
-                {
-                        m_off = m_off*2 + GETBIT(bb,src,ilen);
-                        if (GETBIT(bb,src,ilen)) break;
-                        m_off = (m_off-1)*2 + GETBIT(bb,src,ilen);
-                }
-                if (m_off == 2)
-                {
-                        m_off = last_m_off;
-                        m_len = GETBIT(bb,src,ilen);
-                }
-                else
-                {
-                        m_off = (m_off-3)*256 + src[ilen++];
-                        if (m_off == 0xffffffff)
-                                break;
-                        m_len = (m_off ^ 0xffffffff) & 1;
-                        m_off >>= 1;
-                        last_m_off = ++m_off;
-                }
-                if (m_len)
-                        m_len = 1 + GETBIT(bb,src,ilen);
-                else if (GETBIT(bb,src,ilen))
-                        m_len = 3 + GETBIT(bb,src,ilen);
-                else
-                {
-                        m_len++;
-                        do {
-                                m_len = m_len*2 + GETBIT(bb,src,ilen);
-                        } while (!GETBIT(bb,src,ilen));
-                        m_len += 3;
-                }
-                m_len += (m_off > 0x500);
-                {
-                        const UINT8 *m_pos;
-                        m_pos = dst + olen - m_off;
-                        dst[olen++] = *m_pos++;
-                        do dst[olen++] = *m_pos++; while (--m_len > 0);
-                }
-        }
-        *dst_len = olen;
-
-        return ilen;
+    const UINT8 *src, UINT8 *dst, UINT32* dst_len)
+{
+    UINT32 bb = 0;
+    unsigned ilen = 0, olen = 0, last_m_off = 1;
+
+    for (;;)
+    {
+        unsigned m_off, m_len;
+
+        while (GETBIT(bb,src,ilen))
+        {
+            dst[olen++] = src[ilen++];
+        }
+        m_off = 1;
+        for (;;)
+        {
+            m_off = m_off*2 + GETBIT(bb,src,ilen);
+            if (GETBIT(bb,src,ilen)) break;
+            m_off = (m_off-1)*2 + GETBIT(bb,src,ilen);
+        }
+        if (m_off == 2)
+        {
+            m_off = last_m_off;
+            m_len = GETBIT(bb,src,ilen);
+        }
+        else
+        {
+            m_off = (m_off-3)*256 + src[ilen++];
+            if (m_off == 0xffffffff)
+                break;
+            m_len = (m_off ^ 0xffffffff) & 1;
+            m_off >>= 1;
+            last_m_off = ++m_off;
+        }
+        if (m_len)
+            m_len = 1 + GETBIT(bb,src,ilen);
+        else if (GETBIT(bb,src,ilen))
+            m_len = 3 + GETBIT(bb,src,ilen);
+        else
+        {
+            m_len++;
+            do {
+                m_len = m_len*2 + GETBIT(bb,src,ilen);
+            } while (!GETBIT(bb,src,ilen));
+            m_len += 3;
+        }
+        m_len += (m_off > 0x500);
+        {
+            const UINT8 *m_pos;
+            m_pos = dst + olen - m_off;
+            dst[olen++] = *m_pos++;
+            do dst[olen++] = *m_pos++; while (--m_len > 0);
+        }
+    }
+    *dst_len = olen;
+
+    return ilen;
 }
 
 
-// move the image into place and start it
+/* move the image into place and start it */
 void DecompressStart(tImage* pImage)
 {
-        UINT32* pSrc;
-        UINT32* pDest;
-
-        pSrc = pImage->image;
-        pDest = pImage->pDestination;
-
-        if (pSrc != pDest) // if not linked to that flash address
-        {
-                if (pImage->flags & IF_UCL_2E)
-                {       // UCL compressed, algorithm 2e
-                        UINT32 dst_len; // dummy
-                        ucl_nrv2e_decompress_8((UINT8*)pSrc, (UINT8*)pDest, &dst_len);
-                }
-                else
-                {       // uncompressed, copy it
-                        UINT32 size = pImage->size;
-                        UINT32* pEnd;
-                        size = (size + 3) / 4; // round up to 32bit-words
-                        pEnd = pDest + size;
-
-                        do
-                        {
-                                *pDest++ = *pSrc++;
-                        }
-                        while (pDest < pEnd);
-                }
-        }
-
-        pImage->pExecute();
+    UINT32* pSrc;
+    UINT32* pDest;
+
+    pSrc = pImage->image;
+    pDest = pImage->pDestination;
+
+    if (pSrc != pDest) /* if not linked to that flash address */
+    {
+        if (pImage->flags & IF_UCL_2E)
+        {   /* UCL compressed, algorithm 2e */
+            UINT32 dst_len; /* dummy */
+            ucl_nrv2e_decompress_8((UINT8*)pSrc, (UINT8*)pDest, &dst_len);
+        }
+        else
+        {   /* uncompressed, copy it */
+            UINT32 size = pImage->size;
+            UINT32* pEnd;
+            size = (size + 3) / 4; /* round up to 32bit-words */
+            pEnd = pDest + size;
+
+            do
+            {
+                *pDest++ = *pSrc++;
+            }
+            while (pDest < pEnd);
+        }
+    }
+
+    pImage->pExecute();
 }
 
 #ifdef USE_ADC
 int ReadADC(int channel)
 {
-        // after channel 3, the ports wrap and get re-used
-        volatile UINT16* pResult = (UINT16*)(ADDRAH_ADDR + 2 * (channel & 0x03)); 
-        int timeout = 266; // conversion takes 266 clock cycles
+    /* after channel 3, the ports wrap and get re-used */
+    volatile UINT16* pResult = (UINT16*)(ADDRAH_ADDR + 2 * (channel & 0x03));
+    int timeout = 266; /* conversion takes 266 clock cycles */
 
-        ADCSR = 0x20 | channel; // start single conversion
-        while (((ADCSR & 0x80) == 0) && (--timeout)); // 6 instructions per round
+    ADCSR = 0x20 | channel; /* start single conversion */
+    while (((ADCSR & 0x80) == 0) && (--timeout)); /* 6 instructions per round*/
 
-        return (timeout == 0) ? -1 : *pResult>>6;
+    return (timeout == 0) ? -1 : *pResult>>6;
 }
 #endif
 
 
-// This function is platform-dependent, 
-//      until I figure out how to distinguish at runtime.
-int ButtonPressed(void) // return 1,2,3 for F1,F2,F3, 0 if none pressed
+/* This function is platform-dependent,
+ * until I figure out how to distinguish at runtime. */
+int ButtonPressed(void) /* return 1,2,3 for F1,F2,F3, 0 if none pressed */
 {
 #ifdef USE_ADC
-        int value = ReadADC(CHANNEL);
-
-        if (value >= F1_LOWER && value <= F1_UPPER) // in range
-                return 1;
-        else if (value >= F2_LOWER && value <= F2_UPPER) // in range
-                return 2;
-        else if (value >= F3_LOWER && value <= F3_UPPER) // in range
-                return 3;
+    int value = ReadADC(CHANNEL);
+
+    if (value >= F1_LOWER && value <= F1_UPPER) /* in range */
+        return 1;
+    else if (value >= F2_LOWER && value <= F2_UPPER) /* in range */
+        return 2;
+    else if (value >= F3_LOWER && value <= F3_UPPER) /* in range */
+        return 3;
 #else
     int value = PCDR;
-    
+
     if (!(value & F1_MASK))
         return 1;
     else if (!(value & F2_MASK))
@@ -294,205 +296,209 @@ int ButtonPressed(void) // return 1,2,3 for F1,F2,F3, 0 if none pressed
     else if (!(value & F3_MASK))
         return 3;
 #endif
-        
-        return 0;
+
+    return 0;
 }
 
 
-// Determine the image to be started
+/* Determine the image to be started */
 tImage* GetStartImage(int nPreferred)
 {
-        tImage* pImage1;
-        tImage* pImage2 = NULL; // default to not present
-        UINT32 pos;
-        UINT32* pFlash = (UINT32*)FLASH_BASE;
-
-        // determine the first image position
-        pos = pFlash[2] + pFlash[3]; // position + size of the bootloader = after it
-        pos = (pos + 3) & ~3; // be shure it's 32 bit aligned
-
-        pImage1 = (tImage*)pos;
-
-        if (pImage1->size != 0)
-        {       // check for second image
-                pos = (UINT32)(&pImage1->image) + pImage1->size;
-                pImage2 = (tImage*)pos;
-
-                // does it make sense? (not in FF or 00 erazed space)
-                if (pImage2->pDestination == (void*)0xFFFFFFFF
-                 || pImage2->size == 0xFFFFFFFF
-                 || pImage2->pExecute == (void*)0xFFFFFFFF
-                 || pImage2->flags == 0xFFFFFFFF
-                 || pImage2->pDestination == NULL) // size, execute and flags can legally be 0          
-                {
-                        pImage2 = NULL; // invalidate
-                }
-        }
-
-        if (pImage2 == NULL || nPreferred == 1)
-        {       // no second image or overridden: return the first
-                return pImage1;
-        }
-
-        return pImage2; // return second image
+    tImage* pImage1;
+    tImage* pImage2 = NULL; /* default to not present */
+    UINT32 pos;
+    UINT32* pFlash = (UINT32*)FLASH_BASE;
+
+    /* determine the first image position */
+    pos = pFlash[2] + pFlash[3]; /* position + size of the bootloader
+                                  * = after it */
+    pos = (pos + 3) & ~3; /* be sure it's 32 bit aligned */
+
+    pImage1 = (tImage*)pos;
+
+    if (pImage1->size != 0)
+    {   /* check for second image */
+        pos = (UINT32)(&pImage1->image) + pImage1->size;
+        pImage2 = (tImage*)pos;
+
+        /* does it make sense? (not in FF or 00 erazed space) */
+        if (pImage2->pDestination == (void*)0xFFFFFFFF
+         || pImage2->size == 0xFFFFFFFF
+         || pImage2->pExecute == (void*)0xFFFFFFFF
+         || pImage2->flags == 0xFFFFFFFF
+         || pImage2->pDestination == NULL)
+         /* size, execute and flags can legally be 0 */
+        {
+            pImage2 = NULL; /* invalidate */
+        }
+    }
+
+    if (pImage2 == NULL || nPreferred == 1)
+    {   /* no second image or overridden: return the first */
+        return pImage1;
+    }
+
+    return pImage2; /* return second image */
 }
 
-// diagnostic functions
+/* diagnostic functions */
 
 void SetLed(BOOL bOn)
 {
-        if (bOn)
-                PBDR |= 0x40;
-        else
-                PBDR &= ~0x40;
+    if (bOn)
+        PBDR |= 0x0040;
+    else
+        PBDR &= ~0x0040;
 }
 
 
 void UartInit(void)
 {
-        PBIOR &= 0xFBFF; // input: RXD1 remote pin
-        PBCR1 |= 0x00A0; // set PB3+PB2 to UART
-        PBCR1 &= 0xFFAF; // clear bits 6, 4 -> UART
-        SMR1  =  0x0000; // async format 8N1, baud generator input is CPU clock
-        SCR1  =  0x0030; // transmit+receive enable
-        PBCR1 &= 0x00FF; // set bit 12...15 as GPIO
-        SSR1  &= 0x00BF; // clear bit 6 (RDRF, receive data register full)
+    PBIOR &= 0xFBFF; /* input: RXD1 remote pin */
+    PBCR1 |= 0x00A0; /* set PB11+PB10 to UART */
+    PBCR1 &= 0xFFAF; /* clear bits 6, 4 -> UART */
+    SMR1   = 0x00;   /* async format 8N1, baud generator input is CPU clock */
+    SCR1   = 0x30;   /* transmit+receive enable */
+    PBCR1 &= 0x00FF; /* set bit 12...15 as GPIO */
+    SSR1  &= 0xBF;   /* clear bit 6 (RDRF, receive data register full) */
 }
 
 
 UINT8 UartRead(void)
 {
-        UINT8 byte;
-        while (!(SSR1 & SCI_RDRF)); // wait for char to be available
-        byte = RDR1;
-        SSR1 &= ~SCI_RDRF;
-        return byte;
+    UINT8 byte;
+    while (!(SSR1 & SCI_RDRF)); /* wait for char to be available */
+    byte = RDR1;
+    SSR1 &= ~SCI_RDRF;
+    return byte;
 }
 
 
 void UartWrite(UINT8 byte)
 {
-        while (!(SSR1 & SCI_TDRE)); // wait for transmit buffer empty
-        TDR1 = byte;
-        SSR1 &= ~SCI_TDRE;
+    while (!(SSR1 & SCI_TDRE)); /* wait for transmit buffer empty */
+    TDR1 = byte;
+    SSR1 &= ~SCI_TDRE;
 }
 
 
-// include the mini monitor as a rescue feature, started with F3
+/* include the mini monitor as a rescue feature, started with F3 */
 void MiniMon(void)
 {
-        UINT8 cmd;
-        UINT32 addr;
-        UINT32 size;
-        UINT32 content;
-        volatile UINT8* paddr = NULL;
-        volatile UINT8* pflash = NULL; // flash base address
-
-        UartInit();
-
-        while (1)
-        {
-                cmd = UartRead();
-                switch (cmd)
-                {
-                case BAUDRATE:
-                        content = UartRead();
-                        UartWrite(cmd); // acknowledge by returning the command value
-                        while (!(SSR1 & SCI_TEND)); // wait for empty shift register, before changing baudrate
-                        BRR1 = content;
-                        break;
-
-                case ADDRESS:
-                        addr = (UartRead() << 24) | (UartRead() << 16) | (UartRead() << 8) | UartRead();
-                        paddr = (UINT8*)addr;
-                        pflash = (UINT8*)(addr & 0xFFF80000); // round down to 512k align
-                        UartWrite(cmd); // acknowledge by returning the command value
-                        break;
-
-                case BYTE_READ:
-                        content = *paddr++;
-                        UartWrite(content); // the content is the ack   
-                        break;
-
-                case BYTE_WRITE:
-                        content = UartRead();
-                        *paddr++ = content;
-                        UartWrite(cmd); // acknowledge by returning the command value
-                        break;
-
-                case BYTE_READ16:
-                        size = 16;
-                        while (size--)
-                        {
-                                content = *paddr++;
-                                UartWrite(content); // the content is the ack
-                        }
-                        break;
-
-                case BYTE_WRITE16:
-                        size = 16;
-                        while (size--)
-                        {
-                                content = UartRead();
-                                *paddr++ = content;
-                        }
-                        UartWrite(cmd); // acknowledge by returning the command value
-                        break;
-
-                case BYTE_FLASH:
-                        content = UartRead();
-                        pflash[0x5555] = 0xAA; // set flash to command mode
-                        pflash[0x2AAA] = 0x55;
-                        pflash[0x5555] = 0xA0; // byte program command
-                        *paddr++ = content;
-                        UartWrite(cmd); // acknowledge by returning the command value
-                        break;
-
-                case BYTE_FLASH16:
-                        size = 16;
-                        while (size--)
-                        {
-                                content = UartRead();
-                                pflash[0x5555] = 0xAA; // set flash to command mode
-                                pflash[0x2AAA] = 0x55;
-                                pflash[0x5555] = 0xA0; // byte program command
-                                *paddr++ = content;
-                        }
-                        UartWrite(cmd); // acknowledge by returning the command value
-                        break;
-
-                case HALFWORD_READ:
-                        content = *(UINT16*)paddr;
-                        paddr += 2;
-                        UartWrite(content >> 8); // highbyte
-                        UartWrite(content & 0xFF); // lowbyte
-                        break;
-                
-                case HALFWORD_WRITE:
-                        content = UartRead() << 8 | UartRead();
-                        *(UINT16*)paddr = content;
-                        paddr += 2;
-                        UartWrite(cmd); // acknowledge by returning the command value
-                        break;
-                
-                case EXECUTE:
-                        {
-                                tpFunc pFunc = (tpFunc)paddr;
-                                pFunc();
-                                UartWrite(cmd); // acknowledge by returning the command value
-                        }
-                        break;
-
-                case VERSION:
-                        UartWrite(1); // return our version number
-                        break;
-
-                default:
-                        {
-                                SetLed(TRUE);
-                                UartWrite(~cmd); // error acknowledge
-                        }
-
-                } // case
-        } // while (1)
+    UINT8 cmd;
+    UINT32 addr;
+    UINT32 size;
+    UINT32 content;
+    volatile UINT8* paddr = NULL;
+    volatile UINT8* pflash = NULL; /* flash base address */
+
+    UartInit();
+
+    while (1)
+    {
+        cmd = UartRead();
+        switch (cmd)
+        {
+        case BAUDRATE:
+            content = UartRead();
+            UartWrite(cmd); /* acknowledge by returning the command value */
+            while (!(SSR1 & SCI_TEND)); /* wait for empty shift register,
+                                         * before changing baudrate */
+            BRR1 = content;
+            break;
+
+        case ADDRESS:
+            addr = (UartRead() << 24) | (UartRead() << 16)
+                  | (UartRead() << 8) | UartRead();
+            paddr = (UINT8*)addr;
+            pflash = (UINT8*)(addr & 0xFFF80000); /* round down to 512k align*/
+            UartWrite(cmd); /* acknowledge by returning the command value */
+            break;
+
+        case BYTE_READ:
+            content = *paddr++;
+            UartWrite(content); /* the content is the ack */
+            break;
+
+        case BYTE_WRITE:
+            content = UartRead();
+            *paddr++ = content;
+            UartWrite(cmd); /* acknowledge by returning the command value */
+            break;
+
+        case BYTE_READ16:
+            size = 16;
+            while (size--)
+            {
+                content = *paddr++;
+                UartWrite(content); /* the content is the ack */
+            }
+            break;
+
+        case BYTE_WRITE16:
+            size = 16;
+            while (size--)
+            {
+                content = UartRead();
+                *paddr++ = content;
+            }
+            UartWrite(cmd); /* acknowledge by returning the command value */
+            break;
+
+        case BYTE_FLASH:
+            content = UartRead();
+            pflash[0x5555] = 0xAA; /* set flash to command mode */
+            pflash[0x2AAA] = 0x55;
+            pflash[0x5555] = 0xA0; /* byte program command */
+            *paddr++ = content;
+            UartWrite(cmd); /* acknowledge by returning the command value */
+            break;
+
+        case BYTE_FLASH16:
+            size = 16;
+            while (size--)
+            {
+                content = UartRead();
+                pflash[0x5555] = 0xAA; /* set flash to command mode */
+                pflash[0x2AAA] = 0x55;
+                pflash[0x5555] = 0xA0; /* byte program command */
+                *paddr++ = content;
+            }
+            UartWrite(cmd); /* acknowledge by returning the command value */
+            break;
+
+        case HALFWORD_READ:
+            content = *(UINT16*)paddr;
+            paddr += 2;
+            UartWrite(content >> 8);   /* highbyte */
+            UartWrite(content & 0xFF); /* lowbyte */
+            break;
+
+        case HALFWORD_WRITE:
+            content = UartRead() << 8 | UartRead();
+            *(UINT16*)paddr = content;
+            paddr += 2;
+            UartWrite(cmd); /* acknowledge by returning the command value */
+            break;
+
+        case EXECUTE:
+            {
+                tpFunc pFunc = (tpFunc)paddr;
+                pFunc();
+                UartWrite(cmd); /* acknowledge by returning the command value*/
+            }
+            break;
+
+        case VERSION:
+            UartWrite(1); /* return our version number */
+            break;
+
+        default:
+            {
+                SetLed(TRUE);
+                UartWrite(~cmd); /* error acknowledge */
+            }
+
+        } /* case */
+    } /* while (1) */
 }