flash/bootloader/bootloader.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2003 by Jörg Hohensohn
  11  *
  12  * Second-level bootloader, with dual-boot feature by holding F1/Menu
  13  * This is the image being descrambled and executed by the boot ROM.
  14  * It's task is to copy Rockbox from Flash to DRAM.
  15  * The image(s) in flash may optionally be compressed with UCL 2e
  16  *
  17  * This program is free software; you can redistribute it and/or
  18  * modify it under the terms of the GNU General Public License
  19  * as published by the Free Software Foundation; either version 2
  20  * of the License, or (at your option) any later version.
  21  *
  22  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  23  * KIND, either express or implied.
  24  *
  25  ****************************************************************************/
  26
  27 #include "sh7034.h"
  28 #include "bootloader.h"
  29
  30 // prototypes
  31 static void PlatformInit(void);
  32 static void DecompressStart(tImage* pImage);
  33 #ifdef USE_ADC
  34 static int ReadADC(int channel);
  35 #endif
  36 static int ButtonPressed(void);
  37 static tImage* GetStartImage(int nPreferred);
  38 // test functions
  39 static void SetLed(BOOL bOn);
  40 static void UartInit(void);
  41 static UINT8 UartRead(void);
  42 static void UartWrite(UINT8 byte);
  43 static void MiniMon(void);
  44
  45
  46 #ifdef NO_ROM
  47 /* start with the vector table */
  48 UINT32 vectors[] __attribute__ ((section (".vectors"))) =
  49 {
  50     (UINT32)_main,           /* entry point, the copy routine */
  51     (UINT32)(end_stack - 1), /* initial stack pointer */
  52     FLASH_BASE + 0x200,      /* source of image in flash */
  53     (UINT32)total_size,      /* size of image */
  54     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,
  55     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,
  56     0x03020080 /* mask and version (just as a suggestion) */
  57 };
  58 #else
  59 /* our binary has to start with a vector to the entry point */
  60 tpMain start_vector[] __attribute__ ((section (".startvector"))) = {main};
  61 #endif
  62
  63 #ifdef NO_ROM /* some code which is only needed for the romless variant */
  64 void _main(void)
  65 {
  66     UINT32* pSrc;
  67     UINT32* pDest;
  68     UINT32* pEnd;
  69 /*
  70     asm volatile ("ldc %0,sr" : : "r"(0xF0)); // disable interrupts
  71     asm volatile ("mov.l @%0,r15" : : "r"(4)); // load stack
  72     asm volatile ("ldc %0,vbr" : : "r"(0)); // load vector base
  73 */
  74     /* copy everything to IRAM and continue there */
  75     pSrc = begin_iramcopy;
  76     pDest = begin_text;
  77     pEnd = pDest + (begin_stack - begin_text);
  78
  79     do
  80     {
  81         *pDest++ = *pSrc++;
  82     }
  83     while (pDest < pEnd);
  84
  85     main(); /* jump to the real main() */
  86 }
  87
  88
  89 static void BootInit(void)
  90 {
  91     /* inits from the boot ROM, whether they make sense or not */
  92     PBDR  &= 0xFFBF; /* LED off (0x131E) */
  93     PBCR2  = 0;      /* all GPIO */
  94     PBIOR |= 0x0040; /* LED output */
  95     PBIOR &= 0xFFF1; /* LCD lines input */
  96
  97     /* init DRAM like the boot ROM does */
  98     PACR2 &= 0xFFFB;
  99     PACR2 |= 0x0008;
 100     CASCR  = 0xAF;
 101     BCR   |= 0x8000;
 102     WCR1  &= 0xFDFD;
 103     DCR    = 0x0E00;
 104     RCR    = 0x5AB0;
 105     RTCOR  = 0x9605;
 106     RTCSR  = 0xA518;
 107 }
 108 #endif /* #ifdef NO_ROM */
 109
 110
 111 int main(void)
 112 {
 113     int nButton;
 114
 115     PlatformInit(); /* model-specific inits */
 116
 117     nButton = ButtonPressed();
 118
 119     if (nButton == 3)
 120     {   /* F3 means start monitor */
 121         MiniMon();
 122     }
 123     else
 124     {
 125         tImage* pImage;
 126         pImage = GetStartImage(nButton); /* which image */
 127         DecompressStart(pImage); /* move into place and start it */
 128     }
 129
 130     return 0; /* I guess we won't return  ;-) */
 131 }
 132
 133
 134 /* init code that is specific to certain platform */
 135 static void PlatformInit(void)
 136 {
 137 #ifdef NO_ROM
 138     BootInit(); /* if not started by boot ROM, we need to init what it did */
 139 #endif
 140
 141 #if defined PLATFORM_PLAYER
 142     BRR1    = 0x19; /* 14400 Baud for monitor */
 143     PBDRL  |= 0x10; /* set PB4 to 1 to power the hd early (and prepare for
 144                      * probing in case the charger is connected) */
 145     PBIORL |= 0x10; /* make PB4 an output */
 146     PACR2  &= 0xFFFC; /* GPIO for PA0 (charger detection, input by default) */
 147     if (!(PADRL & 0x01)) /* charger plugged? */
 148     {   /* we need to probe whether the box is able to control hd power */
 149         int i;
 150
 151         PBIORL &= ~0x10; /* set PB4 to input */
 152         /* wait whether it goes low, max. ~1 ms */
 153         for (i = 0; (PBDRL & 0x10) && i < 1000; i++);
 154
 155         if (~(PBDRL & 0x10)) /* pulled low -> power controllable */
 156             PBDRL &= 0x10;   /* set PB4 low */
 157         else                 /* still floating high -> not controllable */
 158             PBDRL |= 0x10;   /* set PB4 high */
 159         PBIORL |= 0x10;      /* ..and output again */
 160     }
 161 #elif defined PLATFORM_RECORDER
 162     BRR1 = 0x02;     /* 115200 Baud for monitor */
 163     if (ReadADC(7) > 0x100) /* charger plugged? */
 164     {   /* switch off the HD, else a flat battery may not start */
 165         PACR2 &= 0xFBFF; /* GPIO for PA5 */
 166         PAIOR |= 0x0020; /* make PA5 an output (low by default) */
 167     }
 168 #elif defined PLATFORM_FM
 169     BRR1   = 0x02;   /* 115200 Baud for monitor */
 170     PBDR  |= 0x0020; /* set PB5 to keep power (fixes the ON-holding problem) */
 171     PBIOR |= 0x0020; /* make PB5 an output */
 172     if (ReadADC(0) < 0x1FF) /* charger plugged? */
 173     {   /* switch off the HD, else a flat battery may not start */
 174         PACR2 &= 0xFBFF; /* GPIO for PA5 */
 175         PAIOR |= 0x0020; /* make PA5 an output (low by default) */
 176     }
 177 #elif defined PLATFORM_ONDIO
 178     BRR1   = 0x19;   /* 14400 Baud for monitor */
 179     PBDR  |= 0x0020; /* set PB5 to keep power (fixes the ON-holding problem) */
 180     PBIOR |= 0x0020; /* make PB5 an output */
 181 #endif
 182
 183     /* platform-independent inits */
 184     DCR |= 0x1000; /* enable burst mode on DRAM */
 185     BCR |= 0x2000; /* activate Warp mode (simultaneous internal and external
 186                     * mem access) */
 187 }
 188
 189
 190 /* move the image into place and start it */
 191 static void DecompressStart(tImage* pImage)
 192 {
 193     UINT32* pSrc;
 194     UINT32* pDest;
 195
 196     pSrc = pImage->image;
 197     pDest = pImage->pDestination;
 198
 199     if (pSrc != pDest) /* if not linked to that flash address */
 200     {
 201         if (pImage->flags & IF_UCL_2E)
 202         {   /* UCL compressed, algorithm 2e */
 203             UINT32 dst_len; /* dummy */
 204             ucl_nrv2e_decompress_8((UINT8*)pSrc, (UINT8*)pDest, &dst_len);
 205         }
 206         else
 207         {   /* uncompressed, copy it */
 208             UINT32 size = pImage->size;
 209             UINT32* pEnd;
 210             size = (size + 3) / 4; /* round up to 32bit-words */
 211             pEnd = pDest + size;
 212
 213             do
 214             {
 215                 *pDest++ = *pSrc++;
 216             }
 217             while (pDest < pEnd);
 218         }
 219     }
 220
 221     pImage->pExecute();
 222 }
 223
 224 #ifdef USE_ADC
 225 static int ReadADC(int channel)
 226 {
 227     /* after channel 3, the ports wrap and get re-used */
 228     volatile UINT16* pResult = (UINT16*)(ADDRAH_ADDR + 2 * (channel & 0x03));
 229     int timeout = 266; /* conversion takes 266 clock cycles */
 230
 231     ADCSR = 0x20 | channel; /* start single conversion */
 232     while (((ADCSR & 0x80) == 0) && (--timeout)); /* 6 instructions per round*/
 233
 234     return (timeout == 0) ? -1 : *pResult>>6;
 235 }
 236 #endif
 237
 238
 239 /* This function is platform-dependent,
 240  * until I figure out how to distinguish at runtime. */
 241 static int ButtonPressed(void) /* return 1,2,3 for F1,F2,F3, 0 if none pressed */
 242 {
 243 #ifdef USE_ADC
 244     int value = ReadADC(CHANNEL);
 245
 246     if (value >= F1_LOWER && value <= F1_UPPER) /* in range */
 247         return 1;
 248     else if (value >= F2_LOWER && value <= F2_UPPER) /* in range */
 249         return 2;
 250     else if (value >= F3_LOWER && value <= F3_UPPER) /* in range */
 251         return 3;
 252 #else
 253     int value = PCDR;
 254
 255     if (!(value & F1_MASK))
 256         return 1;
 257     else if (!(value & F2_MASK))
 258         return 2;
 259     else if (!(value & F3_MASK))
 260         return 3;
 261 #endif
 262
 263     return 0;
 264 }
 265
 266
 267 /* Determine the image to be started */
 268 static tImage* GetStartImage(int nPreferred)
 269 {
 270     tImage* pImage1;
 271     tImage* pImage2 = NULL; /* default to not present */
 272     UINT32 pos;
 273     UINT32* pFlash = (UINT32*)FLASH_BASE;
 274
 275     /* determine the first image position */
 276     pos = pFlash[2] + pFlash[3]; /* position + size of the bootloader
 277                                   * = after it */
 278     pos = (pos + 3) & ~3; /* be sure it's 32 bit aligned */
 279
 280     pImage1 = (tImage*)pos;
 281
 282     if (pImage1->size != 0)
 283     {   /* check for second image */
 284         pos = (UINT32)(&pImage1->image) + pImage1->size;
 285         pImage2 = (tImage*)pos;
 286
 287         /* does it make sense? (not in FF or 00 erazed space) */
 288         if (pImage2->pDestination == (void*)0xFFFFFFFF
 289          || pImage2->size == 0xFFFFFFFF
 290          || pImage2->pExecute == (void*)0xFFFFFFFF
 291          || pImage2->flags == 0xFFFFFFFF
 292          || pImage2->pDestination == NULL)
 293          /* size, execute and flags can legally be 0 */
 294         {
 295             pImage2 = NULL; /* invalidate */
 296         }
 297     }
 298
 299     if (pImage2 == NULL || nPreferred == 1)
 300     {   /* no second image or overridden: return the first */
 301         return pImage1;
 302     }
 303
 304     return pImage2; /* return second image */
 305 }
 306
 307 /* diagnostic functions */
 308
 309 static void SetLed(BOOL bOn)
 310 {
 311     if (bOn)
 312         PBDR |= 0x0040;
 313     else
 314         PBDR &= ~0x0040;
 315 }
 316
 317
 318 static void UartInit(void)
 319 {
 320     PBIOR &= 0xFBFF; /* input: RXD1 remote pin */
 321     PBCR1 |= 0x00A0; /* set PB11+PB10 to UART */
 322     PBCR1 &= 0xFFAF; /* clear bits 6, 4 -> UART */
 323     SMR1   = 0x00;   /* async format 8N1, baud generator input is CPU clock */
 324     SCR1   = 0x30;   /* transmit+receive enable */
 325     PBCR1 &= 0x00FF; /* set bit 12...15 as GPIO */
 326     SSR1  &= 0xBF;   /* clear bit 6 (RDRF, receive data register full) */
 327 }
 328
 329
 330 static UINT8 UartRead(void)
 331 {
 332     UINT8 byte;
 333     while (!(SSR1 & SCI_RDRF)); /* wait for char to be available */
 334     byte = RDR1;
 335     SSR1 &= ~SCI_RDRF;
 336     return byte;
 337 }
 338
 339
 340 static void UartWrite(UINT8 byte)
 341 {
 342     while (!(SSR1 & SCI_TDRE)); /* wait for transmit buffer empty */
 343     TDR1 = byte;
 344     SSR1 &= ~SCI_TDRE;
 345 }
 346
 347
 348 /* include the mini monitor as a rescue feature, started with F3 */
 349 static void MiniMon(void)
 350 {
 351     UINT8 cmd;
 352     UINT32 addr;
 353     UINT32 size;
 354     UINT32 content;
 355     volatile UINT8* paddr = NULL;
 356     volatile UINT8* pflash = NULL; /* flash base address */
 357
 358     UartInit();
 359
 360     while (1)
 361     {
 362         cmd = UartRead();
 363         switch (cmd)
 364         {
 365         case BAUDRATE:
 366             content = UartRead();
 367             UartWrite(cmd); /* acknowledge by returning the command value */
 368             while (!(SSR1 & SCI_TEND)); /* wait for empty shift register,
 369                                          * before changing baudrate */
 370             BRR1 = content;
 371             break;
 372
 373         case ADDRESS:
 374             addr = (UartRead() << 24) | (UartRead() << 16)
 375                   | (UartRead() << 8) | UartRead();
 376             paddr = (UINT8*)addr;
 377             pflash = (UINT8*)(addr & 0xFFF80000); /* round down to 512k align*/
 378             UartWrite(cmd); /* acknowledge by returning the command value */
 379             break;
 380
 381         case BYTE_READ:
 382             content = *paddr++;
 383             UartWrite(content); /* the content is the ack */
 384             break;
 385
 386         case BYTE_WRITE:
 387             content = UartRead();
 388             *paddr++ = content;
 389             UartWrite(cmd); /* acknowledge by returning the command value */
 390             break;
 391
 392         case BYTE_READ16:
 393             size = 16;
 394             while (size--)
 395             {
 396                 content = *paddr++;
 397                 UartWrite(content); /* the content is the ack */
 398             }
 399             break;
 400
 401         case BYTE_WRITE16:
 402             size = 16;
 403             while (size--)
 404             {
 405                 content = UartRead();
 406                 *paddr++ = content;
 407             }
 408             UartWrite(cmd); /* acknowledge by returning the command value */
 409             break;
 410
 411         case BYTE_FLASH:
 412             content = UartRead();
 413             pflash[0x5555] = 0xAA; /* set flash to command mode */
 414             pflash[0x2AAA] = 0x55;
 415             pflash[0x5555] = 0xA0; /* byte program command */
 416             *paddr++ = content;
 417             UartWrite(cmd); /* acknowledge by returning the command value */
 418             break;
 419
 420         case BYTE_FLASH16:
 421             size = 16;
 422             while (size--)
 423             {
 424                 content = UartRead();
 425                 pflash[0x5555] = 0xAA; /* set flash to command mode */
 426                 pflash[0x2AAA] = 0x55;
 427                 pflash[0x5555] = 0xA0; /* byte program command */
 428                 *paddr++ = content;
 429             }
 430             UartWrite(cmd); /* acknowledge by returning the command value */
 431             break;
 432
 433         case HALFWORD_READ:
 434             content = *(UINT16*)paddr;
 435             paddr += 2;
 436             UartWrite(content >> 8);   /* highbyte */
 437             UartWrite(content & 0xFF); /* lowbyte */
 438             break;
 439
 440         case HALFWORD_WRITE:
 441             content = UartRead() << 8 | UartRead();
 442             *(UINT16*)paddr = content;
 443             paddr += 2;
 444             UartWrite(cmd); /* acknowledge by returning the command value */
 445             break;
 446
 447         case EXECUTE:
 448             {
 449                 tpFunc pFunc = (tpFunc)paddr;
 450                 pFunc();
 451                 UartWrite(cmd); /* acknowledge by returning the command value*/
 452             }
 453             break;
 454
 455         case VERSION:
 456             UartWrite(1); /* return our version number */
 457             break;
 458
 459         default:
 460             {
 461                 SetLed(TRUE);
 462                 UartWrite(~cmd); /* error acknowledge */
 463             }
 464
 465         } /* case */
 466     } /* while (1) */
 467 }