apps/plugins/rockbox_flash.c

   1 /***************************************************************************
   2 *             __________               __   ___.
   3 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7 *                     \/            \/     \/    \/            \/
   8 * $Id$
   9 *
  10 * Plugin for reprogramming only the second image in Flash ROM.
  11 * !!! DON'T MESS WITH THIS CODE UNLESS YOU'RE ABSOLUTELY SURE WHAT YOU DO !!!
  12 *
  13 * Copyright (C) 2003 Jörg Hohensohn aka [IDC]Dragon
  14 *
  15 * This program is free software; you can redistribute it and/or
  16 * modify it under the terms of the GNU General Public License
  17 * as published by the Free Software Foundation; either version 2
  18 * of the License, or (at your option) any later version.
  19 *
  20 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  21 * KIND, either express or implied.
  22 *
  23 ****************************************************************************/
  24 #include "plugin.h"
  25
  26 #if (CONFIG_CPU == SH7034) /* Only for SH targets */
  27
  28 PLUGIN_HEADER
  29
  30 /* define DUMMY if you only want to "play" with the UI, does no harm */
  31 /* #define DUMMY */
  32
  33 #define LATEST_BOOTLOADER_VERSION 2 /* update this with the bootloader */
  34
  35 #ifndef UINT8
  36 #define UINT8 unsigned char
  37 #endif
  38
  39 #ifndef UINT16
  40 #define UINT16 unsigned short
  41 #endif
  42
  43 #ifndef UINT32
  44 #define UINT32 unsigned long
  45 #endif
  46
  47 /* hard-coded values */
  48 static volatile UINT8* FB = (UINT8*)0x02000000; /* Flash base address */
  49 #define SECTORSIZE 4096 /* size of one flash sector */
  50
  51 #define ROCKBOX_DEST 0x09000000
  52 #define ROCKBOX_EXEC 0x09000200
  53 #define BOOT_VERS_ADR 0xFA /* position of bootloader version value in Flash */
  54 #define FW_VERS_ADR 0xFE /* position of firmware version value in Flash */
  55 #define UCL_HEADER 26 /* size of the header generated by uclpack */
  56
  57 #if CONFIG_KEYPAD == ONDIO_PAD /* limited keypad */
  58 #define KEY1 BUTTON_LEFT
  59 #define KEY2 BUTTON_UP
  60 #define KEYNAME1 "Left"
  61 #define KEYNAME2 "Up"
  62 #else /* recorder keypad */
  63 #define KEY1 BUTTON_F1
  64 #define KEY2 BUTTON_F2
  65 #define KEYNAME1 "F1"
  66 #define KEYNAME2 "F2"
  67 #endif
  68
  69 typedef struct
  70 {
  71     UINT32 destination; /* address to copy it to */
  72     UINT32 size;        /* how many bytes of payload (to the next header) */
  73     UINT32 execute;     /* entry point */
  74     UINT32 flags;       /* uncompressed or compressed */
  75     /* end of header, now comes the payload */
  76 } tImageHeader;
  77
  78 /* result of the CheckFirmwareFile() function */
  79 typedef enum
  80 {
  81     eOK = 0,
  82     eFileNotFound, /* errors from here on */
  83     eTooBig,
  84     eTooSmall,
  85     eReadErr,
  86     eNotUCL,
  87     eWrongAlgorithm,
  88     eMultiBlocks,
  89     eBadRomLink
  90 } tCheckResult;
  91
  92 typedef struct
  93 {
  94     UINT8 manufacturer;
  95     UINT8 id;
  96     int size;
  97     char name[32];
  98 } tFlashInfo;
  99
 100 static const struct plugin_api* rb; /* here is a global api struct pointer */
 101
 102 static UINT8* sector; /* better not place this on the stack... */
 103
 104 /***************** Flash Functions *****************/
 105
 106
 107 /* read the manufacturer and device ID */
 108 static bool ReadID(volatile UINT8* pBase, UINT8* pManufacturerID,
 109                    UINT8* pDeviceID)
 110 {
 111     UINT8 not_manu, not_id; /* read values before switching to ID mode */
 112     UINT8 manu, id; /* read values when in ID mode */
 113
 114     pBase = (UINT8*)((UINT32)pBase & 0xFFF80000); /* round down to 512k align,
 115                                                      to make sure */
 116
 117     not_manu = pBase[0]; /* read the normal content */
 118     not_id   = pBase[1]; /* should be 'A' (0x41) and 'R' (0x52) from the
 119                             "ARCH" marker */
 120
 121     pBase[0x5555] = 0xAA; /* enter command mode */
 122     pBase[0x2AAA] = 0x55;
 123     pBase[0x5555] = 0x90; /* ID command */
 124     rb->sleep(HZ/50);     /* Atmel wants 20ms pause here */
 125
 126     manu = pBase[0];
 127     id   = pBase[1];
 128
 129     pBase[0] = 0xF0;  /* reset flash (back to normal read mode) */
 130     rb->sleep(HZ/50); /* Atmel wants 20ms pause here */
 131
 132     /* I assume success if the obtained values are different from
 133        the normal flash content. This is not perfectly bulletproof, they
 134        could theoretically be the same by chance, causing us to fail. */
 135     if (not_manu != manu || not_id != id) /* a value has changed */
 136     {
 137         *pManufacturerID = manu; /* return the results */
 138         *pDeviceID = id;
 139         return true; /* success */
 140     }
 141     return false; /* fail */
 142 }
 143
 144 /* erase the sector which contains the given address */
 145 static bool EraseSector(volatile UINT8* pAddr)
 146 {
 147 #ifdef DUMMY
 148     (void)pAddr; /* prevents warning */
 149     return true;
 150 #else
 151     volatile UINT8* pBase =
 152         (UINT8*)((UINT32)pAddr & 0xFFF80000); /* round down to 512k align */
 153     unsigned timeout = 43000; /* the timeout loop should be no less than
 154                                  25ms */
 155
 156     pBase[0x5555] = 0xAA; /* enter command mode */
 157     pBase[0x2AAA] = 0x55;
 158     pBase[0x5555] = 0x80; /* erase command */
 159     pBase[0x5555] = 0xAA; /* enter command mode */
 160     pBase[0x2AAA] = 0x55;
 161     *pAddr = 0x30;        /* erase the sector */
 162
 163     /* I counted 7 instructions for this loop -> min. 0.58 us per round
 164        Plus memory waitstates it will be much more, gives margin */
 165     while (*pAddr != 0xFF && --timeout); /* poll for erased */
 166
 167     return (timeout != 0);
 168 #endif
 169 }
 170
 171 /* address must be in an erased location */
 172 static inline bool ProgramByte(volatile UINT8* pAddr, UINT8 data)
 173 {
 174 #ifdef DUMMY
 175     (void)pAddr; /* prevents warnings */
 176     (void)data;
 177     return true;
 178 #else
 179     unsigned timeout = 35; /* the timeout loop should be no less than 20us */
 180
 181     if (~*pAddr & data) /* just a safety feature, not really necessary */
 182         return false; /* can't set any bit from 0 to 1 */
 183
 184     FB[0x5555] = 0xAA; /* enter command mode */
 185     FB[0x2AAA] = 0x55;
 186     FB[0x5555] = 0xA0; /* byte program command */
 187
 188     *pAddr = data;
 189
 190     /* I counted 7 instructions for this loop -> min. 0.58 us per round
 191        Plus memory waitstates it will be much more, gives margin */
 192     while (*pAddr != data && --timeout); /* poll for programmed */
 193
 194     return (timeout != 0);
 195 #endif
 196 }
 197
 198 /* this returns true if supported and fills the info struct */
 199 static bool GetFlashInfo(tFlashInfo* pInfo)
 200 {
 201     rb->memset(pInfo, 0, sizeof(tFlashInfo));
 202
 203     if (!ReadID(FB, &pInfo->manufacturer, &pInfo->id))
 204         return false;
 205
 206     if (pInfo->manufacturer == 0xBF) /* SST */
 207     {
 208         if (pInfo->id == 0xD6)
 209         {
 210             pInfo->size = 256* 1024; /* 256k */
 211             rb->strcpy(pInfo->name, "SST39VF020");
 212             return true;
 213         }
 214         else if (pInfo->id == 0xD7)
 215         {
 216             pInfo->size = 512* 1024; /* 512k */
 217             rb->strcpy(pInfo->name, "SST39VF040");
 218             return true;
 219         }
 220         else
 221             return false;
 222     }
 223     return false;
 224 }
 225
 226
 227 /*********** Tool Functions ************/
 228
 229 /* read a 32 bit value from memory, big endian */
 230 static UINT32 Read32(UINT8* pByte)
 231 {
 232     UINT32 value;
 233
 234     value = (UINT32)pByte[0] << 24;
 235     value |= (UINT32)pByte[1] << 16;
 236     value |= (UINT32)pByte[2] << 8;
 237     value |= (UINT32)pByte[3];
 238
 239     return value;
 240 }
 241
 242 /* get the start address of the second image */
 243 static tImageHeader* GetSecondImage(void)
 244 {
 245     tImageHeader* pImage1;
 246     UINT32 pos = 0;    /* default: not found */
 247     UINT32* pFlash = (UINT32*)FB;
 248
 249     /* determine the first image position */
 250     pos = pFlash[2] + pFlash[3]; /* position + size of the bootloader
 251                                     = after it */
 252     pos = (pos + 3) & ~3; /* be sure it's 32 bit aligned */
 253     pImage1 = (tImageHeader*)pos;
 254
 255     if (pImage1->destination != ROCKBOX_DEST ||
 256         pImage1->execute != ROCKBOX_EXEC)
 257         return 0; /* seems to be no Archos/Rockbox image in here */
 258
 259     if (pImage1->size != 0)
 260     {
 261         /* success, we have a second image */
 262         pos = (UINT32)pImage1 + sizeof(tImageHeader) + pImage1->size;
 263         if (((pos + SECTORSIZE-1) & ~(SECTORSIZE-1)) != pos)
 264         {    /* not sector-aligned */
 265             pos = 0; /* sanity check failed */
 266         }
 267     }
 268
 269     return (tImageHeader*)pos;
 270 }
 271
 272 /* return bootloader version */
 273 static inline unsigned BootloaderVersion(void)
 274 {
 275     return FB[BOOT_VERS_ADR];
 276 }
 277
 278 /*********** Image File Functions ************/
 279
 280 /* so far, only compressed images in UCL NRV algorithm 2e supported */
 281 tCheckResult CheckImageFile(char* filename, int space,
 282                             tImageHeader* pHeader, UINT8* pos)
 283 {
 284     int i;
 285     int fd;
 286     int filesize; /* size info */
 287
 288     int fileread = 0; /* total size as read from the file */
 289     int read; /* how many for this sector */
 290
 291     /* magic file header for compressed files */
 292     static const UINT8 magic[8] = { 0x00,0xe9,0x55,0x43,0x4c,0xff,0x01,0x1a };
 293     UINT8 ucl_header[UCL_HEADER];
 294
 295     fd = rb->open(filename, O_RDONLY);
 296     if (fd < 0)
 297         return eFileNotFound;
 298
 299     filesize = rb->filesize(fd);
 300     if (filesize - (int)sizeof(ucl_header) - 8 > space)
 301     {
 302         rb->close(fd);
 303         return eTooBig;
 304     }
 305     else if (filesize < 10000) /* give it some reasonable lower limit */
 306     {
 307         rb->close(fd);
 308         return eTooSmall;
 309     }
 310
 311     /* do some sanity checks */
 312
 313     read = rb->read(fd, ucl_header, sizeof(ucl_header));
 314     fileread += read;
 315     if (read != sizeof(ucl_header))
 316     {
 317         rb->close(fd);
 318         return eReadErr;
 319     }
 320
 321     /* compare the magic header */
 322     for (i=0; i<8; i++)
 323     {
 324         if (ucl_header[i] != magic[i])
 325         {
 326             rb->close(fd);
 327             return eNotUCL;
 328         }
 329     }
 330
 331     pHeader->size = Read32(ucl_header + 22); /* compressed size */
 332     if (pHeader->size != filesize - sizeof(ucl_header) - 8)
 333     {
 334         rb->close(fd);
 335         return eMultiBlocks;
 336     }
 337
 338     /* fill in the hardcoded defaults of the header */
 339     pHeader->destination = ROCKBOX_DEST;
 340     pHeader->execute = ROCKBOX_EXEC;
 341
 342     if (Read32(ucl_header + 18) > pHeader->size) /* compare with uncompressed
 343                                                     size */
 344     {   /* compressed, normal case */
 345         pHeader->flags = 0x00000001; /* flags for UCL compressed */
 346
 347         /* check for supported algorithm */
 348         if (ucl_header[12] != 0x2E)
 349         {
 350             rb->close(fd);
 351             return eWrongAlgorithm;
 352         }
 353     }
 354     else
 355     {   /* uncompressed, either to be copied or run directly in flash */
 356         UINT32 reset_vector; /* image has to start with reset vector */
 357
 358         pHeader->flags = 0x00000000; /* uncompressed */
 359
 360         read = rb->read(fd, &reset_vector, sizeof(reset_vector));
 361         fileread += read;
 362         if (read != sizeof(reset_vector))
 363         {
 364             rb->close(fd);
 365             return eReadErr;
 366         }
 367         if (reset_vector >= (UINT32)FB
 368          && reset_vector <  (UINT32)FB+512*1024) /* ROM address? */
 369         {
 370             /* assume in-place, executing directly in flash */
 371             pHeader->destination = (UINT32)(pos + sizeof(tImageHeader));
 372
 373             /* for new RomBox, this isn't the reset vector,
 374                but the link address, for us to check the position */
 375             if(pHeader->destination != reset_vector) /* compare link addr. */
 376             {
 377                 rb->close(fd);
 378                 return eBadRomLink; /* not matching the start address */
 379             }
 380
 381             /* read the now following reset vector */
 382             read = rb->read(fd, &reset_vector, sizeof(reset_vector));
 383             fileread += read;
 384             if (read != sizeof(reset_vector))
 385             {
 386                 rb->close(fd);
 387                 return eReadErr;
 388             }
 389         }
 390
 391         pHeader->execute = reset_vector;
 392     }
 393
 394     /* check if we can read the whole file */
 395     do
 396     {
 397         read = rb->read(fd, sector, SECTORSIZE);
 398         fileread += read;
 399     } while (read == SECTORSIZE);
 400
 401     rb->close(fd);
 402
 403     if (fileread != filesize)
 404         return eReadErr;
 405
 406     return eOK;
 407 }
 408
 409
 410 /* returns the # of failures, 0 on success */
 411 static unsigned ProgramImageFile(char* filename, UINT8* pos,
 412                                  tImageHeader* pImageHeader,
 413                                  int start, int size)
 414 {
 415     int i;
 416     int fd;
 417     int read; /* how many for this sector */
 418     unsigned failures = 0;
 419
 420     fd = rb->open(filename, O_RDONLY);
 421     if (fd < 0)
 422         return false;
 423
 424     /* no error checking necessary here, we checked for minimum size
 425        already */
 426     rb->lseek(fd, start, SEEK_SET); /* go to start position */
 427
 428     *(tImageHeader*)sector = *pImageHeader; /* copy header into sector
 429                                                buffer */
 430     read = rb->read(fd, sector + sizeof(tImageHeader),
 431                     SECTORSIZE - sizeof(tImageHeader)); /* payload behind */
 432     size -= read;
 433     read += sizeof(tImageHeader); /* to be programmed, but not part of the
 434                                      file */
 435
 436     do {
 437         if (!EraseSector(pos))
 438         {
 439             /* nothing we can do, let the programming count the errors */
 440         }
 441
 442         for (i=0; i<read; i++)
 443         {
 444             if (!ProgramByte(pos + i, sector[i]))
 445             {
 446                 failures++;
 447             }
 448         }
 449
 450         pos += SECTORSIZE;
 451         read = rb->read(fd, sector, (size > SECTORSIZE) ? SECTORSIZE : size);
 452         /* payload for next sector */
 453         size -= read;
 454     } while (read > 0);
 455
 456     rb->close(fd);
 457
 458     return failures;
 459 }
 460
 461 /* returns the # of failures, 0 on success */
 462 static unsigned VerifyImageFile(char* filename, UINT8* pos,
 463                                 tImageHeader* pImageHeader,
 464                                 int start, int size)
 465 {
 466     int i;
 467     int fd;
 468     int read; /* how many for this sector */
 469     unsigned failures = 0;
 470
 471     fd = rb->open(filename, O_RDONLY);
 472     if (fd < 0)
 473         return false;
 474
 475     /* no error checking necessary here, we checked for minimum size
 476        already */
 477     rb->lseek(fd, start, SEEK_SET); /* go to start position */
 478
 479     *(tImageHeader*)sector = *pImageHeader; /* copy header into sector
 480                                                buffer */
 481     read = rb->read(fd, sector + sizeof(tImageHeader),
 482                     SECTORSIZE - sizeof(tImageHeader)); /* payload behind */
 483
 484     size -= read;
 485     read += sizeof(tImageHeader); /* to be programmed, but not part of the
 486                                      file */
 487
 488     do
 489     {
 490         for (i=0; i<read; i++)
 491         {
 492             if (pos[i] != sector[i])
 493             {
 494                 failures++;
 495             }
 496         }
 497
 498         pos += SECTORSIZE;
 499         read = rb->read(fd, sector, (size > SECTORSIZE) ? SECTORSIZE : size);
 500         /* payload for next sector */
 501         size -= read;
 502     } while (read);
 503
 504     rb->close(fd);
 505
 506     return failures;
 507 }
 508
 509
 510 /***************** User Interface Functions *****************/
 511
 512 static int WaitForButton(void)
 513 {
 514     int button;
 515
 516     do
 517     {
 518         button = rb->button_get(true);
 519     } while (button & BUTTON_REL);
 520
 521     return button;
 522 }
 523
 524 #ifdef HAVE_LCD_BITMAP
 525 /* helper for DoUserDialog() */
 526 static void ShowFlashInfo(tFlashInfo* pInfo, tImageHeader* pImageHeader)
 527 {
 528     char buf[32];
 529
 530     if (!pInfo->manufacturer)
 531     {
 532         rb->lcd_puts_scroll(0, 0, "Flash: M=?? D=??");
 533     }
 534     else
 535     {
 536         if (pInfo->size)
 537         {
 538             rb->snprintf(buf, sizeof(buf), "Flash size: %d KB",
 539                          pInfo->size / 1024);
 540             rb->lcd_puts_scroll(0, 0, buf);
 541         }
 542         else
 543         {
 544             rb->lcd_puts_scroll(0, 0, "Unsupported chip");
 545         }
 546
 547     }
 548
 549     if (pImageHeader)
 550     {
 551         rb->snprintf(buf, sizeof(buf), "Image at %d KB",
 552                      ((UINT8*)pImageHeader - FB) / 1024);
 553         rb->lcd_puts_scroll(0, 1, buf);
 554     }
 555     else
 556     {
 557         rb->lcd_puts_scroll(0, 1, "No image found!");
 558     }
 559 }
 560
 561
 562 /* Kind of our main function, defines the application flow. */
 563 /* recorder version */
 564 static void DoUserDialog(char* filename)
 565 {
 566     tImageHeader ImageHeader;
 567     tFlashInfo FlashInfo;
 568     static char buf[MAX_PATH];
 569     int button;
 570     int rc; /* generic return code */
 571     UINT32 space, aligned_size, true_size;
 572     UINT8* pos;
 573     ssize_t memleft;
 574     unsigned bl_version;
 575     bool show_greet = false;
 576
 577     /* this can only work if Rockbox runs in DRAM, not flash ROM */
 578     if ((UINT8*)rb >= FB && (UINT8*)rb < FB + 4096*1024) /* 4 MB max */
 579     {   /* we're running from flash */
 580         rb->splash(HZ*3, "Not from ROM");
 581         return; /* exit */
 582     }
 583
 584     /* refuse to work if the power may fail meanwhile */
 585     if (!rb->battery_level_safe())
 586     {
 587         rb->splash(HZ*3, "Battery too low!");
 588         return; /* exit */
 589     }
 590
 591     /* "allocate" memory */
 592     sector = rb->plugin_get_buffer((size_t *)&memleft);
 593     if (memleft < SECTORSIZE) /* need buffer for a flash sector */
 594     {
 595         rb->splash(HZ*3, "Out of memory");
 596         return; /* exit */
 597     }
 598
 599     rb->lcd_setfont(FONT_SYSFIXED);
 600
 601     pos = (void*)GetSecondImage();
 602     rc = GetFlashInfo(&FlashInfo);
 603
 604     ShowFlashInfo(&FlashInfo, (void*)pos);
 605     rb->lcd_update();
 606
 607     if (FlashInfo.size == 0) /* no valid chip */
 608     {
 609         rb->splash(HZ*3, "Not flashable");
 610         return; /* exit */
 611     }
 612     else if (pos == 0)
 613     {
 614         rb->splash(HZ*3, "No image");
 615         return; /* exit */
 616     }
 617
 618     bl_version = BootloaderVersion();
 619     if (bl_version < LATEST_BOOTLOADER_VERSION)
 620     {
 621         rb->snprintf(buf, sizeof(buf), "Bootloader V%d", bl_version);
 622         rb->lcd_puts(0, 0, buf);
 623         rb->lcd_puts(0, 1, "Hint: You're not  ");
 624         rb->lcd_puts(0, 2, "using the latest  ");
 625         rb->lcd_puts(0, 3, "bootloader.       ");
 626         rb->lcd_puts(0, 4, "A full reflash is ");
 627         rb->lcd_puts(0, 5, "recommended, but  ");
 628         rb->lcd_puts(0, 6, "not required.     ");
 629         rb->lcd_puts(0, 7, "Press " KEYNAME1 " to ignore");
 630         rb->lcd_update();
 631
 632         if (WaitForButton() != KEY1)
 633         {
 634             return;
 635         }
 636         rb->lcd_clear_display();
 637     }
 638
 639     rb->lcd_puts(0, show_greet ? 0 : 3, "Checking...");
 640     rb->lcd_update();
 641
 642     space = FlashInfo.size - (pos-FB + sizeof(ImageHeader));
 643     /* size minus start */
 644
 645     rc = CheckImageFile(filename, space, &ImageHeader, pos);
 646     if (rc != eOK)
 647     {
 648         rb->lcd_clear_display(); /* make room for error message */
 649         show_greet = true; /* verbose */
 650     }
 651
 652     rb->lcd_puts(0, show_greet ? 0 : 3, "Checked:");
 653     switch (rc) {
 654         case eOK:
 655             rb->lcd_puts(0, show_greet ? 0 : 4, "File OK.");
 656             break;
 657     case eNotUCL:
 658             rb->lcd_puts(0, 1, "File not UCL ");
 659             rb->lcd_puts(0, 2, "compressed.");
 660             rb->lcd_puts(0, 3, "Use uclpack --2e");
 661             rb->lcd_puts(0, 4, " --10 rockbox.bin");
 662             break;
 663     case eWrongAlgorithm:
 664             rb->lcd_puts(0, 1, "Wrong algorithm");
 665             rb->lcd_puts(0, 2, "for compression.");
 666             rb->lcd_puts(0, 3, "Use uclpack --2e");
 667             rb->lcd_puts(0, 4, " --10 rockbox.bin");
 668             break;
 669     case eFileNotFound:
 670             rb->lcd_puts(0, 1, "File not found:");
 671             rb->lcd_puts_scroll(0, 2, filename);
 672             break;
 673     case eTooBig:
 674             rb->lcd_puts(0, 1, "File too big,");
 675             rb->lcd_puts(0, 2, "won't fit in chip.");
 676             break;
 677     case eTooSmall:
 678             rb->lcd_puts(0, 1, "File too small.");
 679             rb->lcd_puts(0, 2, "Incomplete?");
 680             break;
 681     case eReadErr:
 682             rb->lcd_puts(0, 1, "File read error.");
 683             break;
 684     case eMultiBlocks:
 685             rb->lcd_puts(0, 1, "File invalid.");
 686             rb->lcd_puts(0, 2, "Blocksize");
 687             rb->lcd_puts(0, 3, " too small?");
 688             break;
 689     case eBadRomLink:
 690             rb->lcd_puts(0, 1, "RomBox mismatch.");
 691             rb->lcd_puts(0, 2, "Wrong ROM position");
 692             break;
 693     default:
 694             rb->lcd_puts(0, 1, "Check failed.");
 695             break;
 696     }
 697
 698     if (rc == eOK)
 699     {    /* was OK */
 700         rb->lcd_puts(0, 6, "[" KEYNAME2 "] to program");
 701         rb->lcd_puts(0, 7, "other key to exit");
 702     }
 703     else
 704     { /* error occured */
 705         rb->lcd_puts(0, 6, "Any key to exit");
 706     }
 707     rb->lcd_update();
 708
 709     button = WaitForButton();
 710     if (rc != eOK || button != KEY2)
 711     {
 712         return;
 713     }
 714
 715     true_size = ImageHeader.size;
 716     aligned_size = ((sizeof(tImageHeader) + true_size + SECTORSIZE-1) &
 717                     ~(SECTORSIZE-1)) - sizeof(tImageHeader); /* round up to
 718                                                                 next flash
 719                                                                 sector */
 720     ImageHeader.size = aligned_size; /* increase image size such that we reach
 721                                         the next sector */
 722
 723     rb->lcd_clear_display();
 724     rb->lcd_puts_scroll(0, 0, "Programming...");
 725     rb->lcd_update();
 726
 727     rc = ProgramImageFile(filename, pos, &ImageHeader, UCL_HEADER, true_size);
 728     if (rc)
 729     {   /* errors */
 730         rb->lcd_clear_display();
 731         rb->snprintf(buf, sizeof(buf), "%d errors", rc);
 732         rb->lcd_puts(0, 0, "Error:");
 733         rb->lcd_puts(0, 1, "Programming fail!");
 734         rb->lcd_puts(0, 2, buf);
 735         rb->lcd_update();
 736         button = WaitForButton();
 737     }
 738
 739     rb->lcd_clear_display();
 740     rb->lcd_puts_scroll(0, 0, "Verifying...");
 741     rb->lcd_update();
 742
 743     rc = VerifyImageFile(filename, pos, &ImageHeader, UCL_HEADER, true_size);
 744
 745     rb->lcd_clear_display();
 746     if (rc == 0)
 747     {
 748         rb->lcd_puts(0, 0, "Verify OK.");
 749     }
 750     else
 751     {
 752         rb->snprintf(buf, sizeof(buf), "%d errors", rc);
 753         rb->lcd_puts(0, 0, "Error:");
 754         rb->lcd_puts(0, 1, "Verify fail!");
 755         rb->lcd_puts(0, 2, buf);
 756         rb->lcd_puts(0, 3, "Use safe image");
 757         rb->lcd_puts(0, 4, "if booting hangs:");
 758         rb->lcd_puts(0, 5, "F1 during power-on");
 759     }
 760     rb->lcd_puts(0, 7, "Any key to exit");
 761     rb->lcd_update();
 762     WaitForButton();
 763 }
 764
 765 #else /* #ifdef HAVE_LCD_BITMAP */
 766
 767 /* Player version */
 768 static void DoUserDialog(char* filename)
 769 {
 770     tImageHeader ImageHeader;
 771     tFlashInfo FlashInfo;
 772     static char buf[MAX_PATH];
 773     int button;
 774     int rc; /* generic return code */
 775     UINT32 space, aligned_size, true_size;
 776     UINT8* pos;
 777     ssize_t memleft;
 778     unsigned bl_version;
 779
 780     /* this can only work if Rockbox runs in DRAM, not flash ROM */
 781     if ((UINT8*)rb >= FB && (UINT8*)rb < FB + 4096*1024) /* 4 MB max */
 782     {   /* we're running from flash */
 783         rb->splash(HZ*3, "Not from ROM");
 784         return; /* exit */
 785     }
 786
 787     /* refuse to work if the power may fail meanwhile */
 788     if (!rb->battery_level_safe())
 789     {
 790         rb->splash(HZ*3, "Batt. too low!");
 791         return; /* exit */
 792     }
 793
 794     /* "allocate" memory */
 795     sector = rb->plugin_get_buffer((size_t *)&memleft);
 796     if (memleft < SECTORSIZE) /* need buffer for a flash sector */
 797     {
 798         rb->splash(HZ*3, "Out of memory");
 799         return; /* exit */
 800     }
 801
 802     pos = (void*)GetSecondImage();
 803     rc = GetFlashInfo(&FlashInfo);
 804
 805     if (FlashInfo.size == 0) /* no valid chip */
 806     {
 807         rb->splash(HZ*3, "Not flashable");
 808         return; /* exit */
 809     }
 810     else if (pos == 0)
 811     {
 812         rb->splash(HZ*3, "No image");
 813         return; /* exit */
 814     }
 815
 816     bl_version = BootloaderVersion();
 817     if (bl_version < LATEST_BOOTLOADER_VERSION)
 818     {
 819         rb->lcd_puts_scroll(0, 0, "Hint: You're not using the latest bootloader. A full reflash is recommended, but not required.");
 820         rb->lcd_puts_scroll(0, 1, "Press [Menu] to ignore");
 821         rb->lcd_update();
 822
 823         if (WaitForButton() != BUTTON_MENU)
 824         {
 825             return;
 826         }
 827         rb->lcd_clear_display();
 828     }
 829
 830     rb->lcd_puts(0, 0, "Checking...");
 831     rb->lcd_update();
 832
 833     space = FlashInfo.size - (pos-FB + sizeof(ImageHeader));
 834     /* size minus start */
 835
 836     rc = CheckImageFile(filename, space, &ImageHeader, pos);
 837     rb->lcd_puts(0, 0, "Checked:");
 838     switch (rc) {
 839         case eOK:
 840             rb->lcd_puts(0, 1, "File OK.");
 841             rb->sleep(HZ*1);
 842             break;
 843     case eNotUCL:
 844             rb->lcd_puts_scroll(0, 1, "File not UCL compressed.");
 845             break;
 846     case eWrongAlgorithm:
 847             rb->lcd_puts_scroll(0, 1, "Wrong compression algorithm.");
 848             break;
 849     case eFileNotFound:
 850             rb->lcd_puts_scroll(0, 1, "File not found.");
 851             break;
 852     case eTooBig:
 853             rb->lcd_puts_scroll(0, 1, "File too big.");
 854             break;
 855     case eTooSmall:
 856             rb->lcd_puts_scroll(0, 1, "File too small. Incomplete?");
 857             break;
 858     case eReadErr:
 859             rb->lcd_puts_scroll(0, 1, "File read error.");
 860             break;
 861     case eMultiBlocks:
 862             rb->lcd_puts_scroll(0, 1, "File invalid. Blocksize too small?");
 863             break;
 864     case eBadRomLink:
 865             rb->lcd_puts_scroll(0, 1, "RomBox mismatch.");
 866             break;
 867     default:
 868             rb->lcd_puts_scroll(0, 1, "Check failed.");
 869             break;
 870     }
 871     rb->lcd_update();
 872
 873     if (rc == eOK)
 874     {    /* was OK */
 875         rb->lcd_clear_display();
 876         rb->lcd_puts_scroll(0, 0, "[ON] to program,");
 877         rb->lcd_puts_scroll(0, 1, "other key to exit.");
 878     }
 879     else
 880     { /* error occured */
 881         WaitForButton();
 882         rb->lcd_clear_display();
 883         rb->lcd_puts_scroll(0, 0, "Flash failed.");
 884         rb->lcd_puts_scroll(0, 1, "Any key to exit.");
 885     }
 886     rb->lcd_update();
 887
 888     button = WaitForButton();
 889     if (rc != eOK || button != BUTTON_ON)
 890     {
 891         return;
 892     }
 893
 894     true_size = ImageHeader.size;
 895     aligned_size = ((sizeof(tImageHeader) + true_size + SECTORSIZE-1) &
 896                     ~(SECTORSIZE-1)) - sizeof(tImageHeader); /* round up to
 897                                                                 next flash
 898                                                                 sector */
 899     ImageHeader.size = aligned_size; /* increase image size such that we reach
 900                                         the next sector */
 901
 902     rb->lcd_clear_display();
 903     rb->lcd_puts_scroll(0, 0, "Programming...");
 904     rb->lcd_update();
 905
 906     rc = ProgramImageFile(filename, pos, &ImageHeader, UCL_HEADER, true_size);
 907     if (rc)
 908     {   /* errors */
 909         rb->lcd_clear_display();
 910         rb->snprintf(buf, sizeof(buf), "%d errors", rc);
 911         rb->lcd_puts_scroll(0, 0, "Programming failed!");
 912         rb->lcd_puts_scroll(0, 1, buf);
 913         rb->lcd_update();
 914         button = WaitForButton();
 915     }
 916
 917     rb->lcd_clear_display();
 918     rb->lcd_puts_scroll(0, 0, "Verifying...");
 919     rb->lcd_update();
 920
 921     rc = VerifyImageFile(filename, pos, &ImageHeader, UCL_HEADER, true_size);
 922
 923     rb->lcd_clear_display();
 924     if (rc == 0)
 925     {
 926         rb->lcd_puts(0, 0, "Verify OK.");
 927         rb->lcd_update();
 928     }
 929     else
 930     {
 931         rb->snprintf(buf, sizeof(buf), "Verify fail! %d errors", rc);
 932         rb->lcd_puts_scroll(0, 0, buf);
 933         rb->lcd_puts_scroll(0, 1, "Use safe image if booting hangs: [-] during power-on");
 934         rb->lcd_update();
 935         button = WaitForButton();
 936     }
 937 }
 938
 939 #endif /* not HAVE_LCD_BITMAP */
 940
 941
 942
 943 /***************** Plugin Entry Point *****************/
 944
 945 enum plugin_status plugin_start(const struct plugin_api* api, const void* parameter)
 946 {
 947     int oldmode;
 948
 949     rb = api; /* copy to global api pointer */
 950
 951     if (parameter == NULL)
 952     {
 953         rb->splash(HZ*3, "Play .ucl file!");
 954         return PLUGIN_OK;
 955     }
 956
 957     /* now go ahead and have fun! */
 958     oldmode = rb->system_memory_guard(MEMGUARD_NONE); /*disable memory guard */
 959     DoUserDialog((char*) parameter);
 960     rb->system_memory_guard(oldmode);              /* re-enable memory guard */
 961
 962     return PLUGIN_OK;
 963 }
 964
 965
 966 #endif /* SH-target */