1 files changed, 664 insertions, 0 deletions

diff --git a/apps/plugins/rockbox_flash.c b/apps/plugins/rockbox_flash.c
new file mode 100644
index 0000000000..829cc5a346
--- /dev/null
+++ b/apps/plugins/rockbox_flash.c
@@ -0,0 +1,664 @@
+/***************************************************************************
+*             __________               __   ___.
+*   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+*   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+*   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+*   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+*                     \/            \/     \/    \/            \/
+* $Id$
+*
+* Plugin for reprogramming only the second Rockbox image.
+*
+* Copyright (C) 2003 Jörg Hohensohn [IDC]Dragon
+*
+* All files in this archive are subject to the GNU General Public License.
+* See the file COPYING in the source tree root for full license agreement.
+*
+* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+* KIND, either express or implied.
+*
+****************************************************************************/
+#include "plugin.h"
+
+#ifndef UINT8
+#define UINT8 unsigned char
+#endif
+
+#ifndef UINT16
+#define UINT16 unsigned short
+#endif
+
+#ifndef UINT32
+#define UINT32 unsigned long
+#endif
+
+// hard-coded values
+static volatile UINT8* FB = (UINT8*)0x02000000; // Flash base address
+#define SECTORSIZE 4096 // size of one flash sector
+
+#define ROCKBOX_DEST 0x09000000
+#define ROCKBOX_EXEC 0x09000200
+#define FILENAME "/rockbox.ucl"
+#define VERS_ADR 0xFE // position of firmware version value in Flash
+#define UCL_HEADER 26 // size of the header generated by uclpack
+
+typedef struct 
+{
+        UINT32 destination; // address to copy it to
+        UINT32 size;          // how many bytes of payload (to the next header)
+        UINT32 execute;      // entry point
+        UINT32 flags;         // uncompressed or compressed
+        // end of header, now comes the payload
+} tImageHeader;
+
+
+// result of the CheckFirmwareFile() function
+typedef enum
+{
+        eOK = 0,
+        eFileNotFound, // errors from here on
+        eTooBig,
+        eTooSmall,
+        eReadErr,
+        eNotUCL,
+        eWrongAlgorithm,
+        eMultiBlocks,
+} tCheckResult;
+
+typedef struct 
+{
+        UINT8 manufacturer;
+        UINT8 id;
+        int size;
+        char name[32];
+} tFlashInfo;
+
+static struct plugin_api* rb; // here is a global api struct pointer
+
+#define SEC_SIZE 4096 // size of one flash sector
+static UINT8 sector[SEC_SIZE]; // better not place this on the stack...
+
+
+/***************** Flash Functions *****************/
+
+
+// read the manufacturer and device ID
+bool ReadID(volatile UINT8* pBase, UINT8* pManufacturerID, UINT8* pDeviceID)
+{
+        UINT8 not_manu, not_id; // read values before switching to ID mode
+        UINT8 manu, id; // read values when in ID mode
+        
+        pBase = (UINT8*)((UINT32)pBase & 0xFFF80000); // round down to 512k align, to make shure
+        
+        not_manu = pBase[0]; // read the normal content
+        not_id   = pBase[1]; // should be 'A' (0x41) and 'R' (0x52) from the "ARCH" marker
+        
+        pBase[0x5555] = 0xAA; // enter command mode
+        pBase[0x2AAA] = 0x55;
+        pBase[0x5555] = 0x90; // ID command
+        rb->sleep(HZ/50); // Atmel wants 20ms pause here
+        
+        manu = pBase[0];
+        id   = pBase[1];
+        
+        pBase[0] = 0xF0; // reset flash (back to normal read mode)
+        rb->sleep(HZ/50); // Atmel wants 20ms pause here
+        
+        /* I assume success if the obtained values are different from
+        the normal flash content. This is not perfectly bulletproof, they 
+        could theoretically be the same by chance, causing us to fail. */
+        if (not_manu != manu || not_id != id) // a value has changed
+        {
+                *pManufacturerID = manu; // return the results
+                *pDeviceID = id;
+                return true; // success
+        }
+        return false; // fail
+}
+
+
+// eraze the sector which contains the given address
+bool ErazeSector(volatile UINT8* pAddr)
+{
+        volatile UINT8* pBase = (UINT8*)((UINT32)pAddr & 0xFFF80000); // round down to 512k align
+        unsigned timeout = 43000; // the timeout loop should be no less than 25ms
+        
+        pBase[0x5555] = 0xAA; // enter command mode
+        pBase[0x2AAA] = 0x55;
+        pBase[0x5555] = 0x80; // eraze command
+        pBase[0x5555] = 0xAA; // enter command mode
+        pBase[0x2AAA] = 0x55;
+        *pAddr = 0x30; // eraze the sector
+
+        // I counted 7 instructions for this loop -> min. 0.58 us per round
+        // Plus memory waitstates it will be much more, gives margin
+        while (*pAddr != 0xFF && --timeout); // poll for erazed
+
+        return (timeout != 0);
+}
+
+// address must be in an erazed location
+inline bool ProgramByte(volatile UINT8* pAddr, UINT8 data)
+{
+        unsigned timeout = 35; // the timeout loop should be no less than 20us
+        
+        if (~*pAddr & data) // just a safety feature, not really necessary
+                return false; // can't set any bit from 0 to 1
+        
+        FB[0x5555] = 0xAA; // enter command mode
+        FB[0x2AAA] = 0x55;
+        FB[0x5555] = 0xA0; // byte program command
+        
+        *pAddr = data;
+        
+        // I counted 7 instructions for this loop -> min. 0.58 us per round
+        // Plus memory waitstates it will be much more, gives margin
+        while (*pAddr != data && --timeout); // poll for programmed
+        
+        return (timeout != 0);
+}
+
+// this returns true if supported and fills the info struct
+bool GetFlashInfo(tFlashInfo* pInfo)
+{
+        rb->memset(pInfo, 0, sizeof(tFlashInfo));
+        
+        if (!ReadID(FB, &pInfo->manufacturer, &pInfo->id))
+                return false;
+        
+        if (pInfo->manufacturer == 0xBF) // SST
+        {
+                if (pInfo->id == 0xD6)
+                {
+                        pInfo->size = 256* 1024; // 256k
+                        rb->strcpy(pInfo->name, "SST39VF020");
+                        return true;
+                }
+                else if (pInfo->id == 0xD7)
+                {
+                        pInfo->size = 512* 1024; // 512k
+                        rb->strcpy(pInfo->name, "SST39VF040");
+                        return true;
+                }
+                else
+                        return false;
+        }
+        return false;
+}
+
+
+/*********** Tool Functions ************/
+
+// place a 32 bit value into memory, big endian
+void Write32(UINT8* pByte, UINT32 value)
+{
+        pByte[0] = (UINT8)(value >> 24);        
+        pByte[1] = (UINT8)(value >> 16);        
+        pByte[2] = (UINT8)(value >> 8); 
+        pByte[3] = (UINT8)(value);      
+}
+
+// read a 32 bit value from memory, big endian
+UINT32 Read32(UINT8* pByte)
+{
+        UINT32 value = 0;
+
+        value |= (UINT32)pByte[0] << 24;
+        value |= (UINT32)pByte[1] << 16;
+        value |= (UINT32)pByte[2] << 8;
+        value |= (UINT32)pByte[3];
+
+        return value;
+}
+
+
+// get the start address of the second image
+tImageHeader* GetSecondImage(void)
+{
+        tImageHeader* pImage1;
+        UINT32 pos = 0; // dafault: not found
+        UINT32* pFlash = (UINT32*)FB;
+
+        UINT16 version = *(UINT16*)(FB + VERS_ADR);
+        if (version < 200) // at least 2.00
+        {
+                return 0; // not our flash layout
+        }
+
+        // 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 = (tImageHeader*)pos;
+
+        if (pImage1->destination != ROCKBOX_DEST || pImage1->execute != ROCKBOX_EXEC)
+                return 0; // seems to be no Rockbox stuff in here
+
+        if (pImage1->size != 0)
+        {       // success, we have a second image
+                pos = (UINT32)pImage1 + sizeof(tImageHeader) + pImage1->size;
+                if (((pos + SECTORSIZE-1) & ~(SECTORSIZE-1)) != pos)
+                {       // not sector-aligned
+                        pos = 0; // sanity check failed
+                }
+        }
+
+        return (tImageHeader*)pos;
+}
+
+
+/*********** Image File Functions ************/
+
+// so far, only compressed images in UCL NRV algorithm 2e supported
+tCheckResult CheckImageFile(char* filename, int space, tImageHeader* pHeader)
+{
+        int i;
+        int fd;
+        int filesize; // size info
+
+        int fileread = 0; // total size as read from the file
+        int read; // how many for this sector
+        
+        // magic file header for compressed files
+        static const UINT8 magic[8] = { 0x00,0xe9,0x55,0x43,0x4c,0xff,0x01,0x1a };
+        UINT8 ucl_header[UCL_HEADER];
+
+        fd = rb->open(filename, O_RDONLY);
+        if (fd < 0)
+                return eFileNotFound;
+        
+        filesize = rb->filesize(fd);
+        if (filesize - (int)sizeof(ucl_header) - 8 > space)
+        {
+                rb->close(fd);
+                return eTooBig;
+        }
+        else if (filesize < 50000) // give it some reasonable lower limit
+        {
+                rb->close(fd);
+                return eTooSmall;
+        }
+        
+        // do some sanity checks
+        
+        read = rb->read(fd, ucl_header, sizeof(ucl_header));
+        fileread += read;
+        if (read != sizeof(ucl_header))
+        {
+                rb->close(fd);
+                return eReadErr;
+        }
+        
+        // compare the magic header
+        for (i=0; i<8; i++)
+        {
+                if (ucl_header[i] != magic[i])
+                {
+                        rb->close(fd);
+                        return eNotUCL;
+                }
+        }
+        
+        // check for supported algorithm
+        if (ucl_header[12] != 0x2E)
+        {
+                rb->close(fd);
+                return eWrongAlgorithm;
+        }
+
+        pHeader->size = Read32(ucl_header + 22); // compressed size
+        if (pHeader->size != filesize - sizeof(ucl_header) - 8)
+        {
+                rb->close(fd);
+                return eMultiBlocks;
+        }
+        
+        if (Read32(ucl_header + 18) > pHeader->size) // compare with uncompressed size
+        {       // normal case
+                pHeader->flags = 0x00000001; // flags for UCL compressed
+        }
+        else
+        {
+                pHeader->flags = 0x00000000; // very unlikely, content was not compressible
+        }
+        
+        // check if we can read the whole file
+        do
+        {
+                read = rb->read(fd, sector, SEC_SIZE);
+                fileread += read;
+        } while (read == SEC_SIZE);
+        
+        rb->close(fd);
+        
+        if (fileread != filesize)
+                return eReadErr;
+        
+        // fill in the hardcoded rest of the header
+        pHeader->destination = ROCKBOX_DEST;
+        pHeader->execute = ROCKBOX_EXEC;
+        
+        return eOK;
+}
+
+
+// returns the # of failures, 0 on success
+unsigned ProgramImageFile(char* filename, UINT8* pos, tImageHeader* pImageHeader, int start, int size)
+{
+        int i;
+        int fd;
+        int read; // how many for this sector
+        unsigned failures = 0;
+        
+        fd = rb->open(filename, O_RDONLY);
+        if (fd < 0)
+                return false;
+
+        // no error checking necessary here, we checked for minimum size already
+        rb->lseek(fd, start, SEEK_SET); // go to start position
+        
+        *(tImageHeader*)sector = *pImageHeader; // copy header into sector buffer
+        read = rb->read(fd, sector + sizeof(tImageHeader), SEC_SIZE - sizeof(tImageHeader)); // payload behind
+        size -= read;
+        read += sizeof(tImageHeader); // to be programmed, but not part of the file
+
+        do
+        {
+                if (!ErazeSector(pos))
+                {
+                        // nothing we can do, let the programming count the errors
+                }
+                
+                for (i=0; i<read; i++)
+                {
+                        if (!ProgramByte(pos + i, sector[i]))
+                        {
+                                failures++;
+                        }
+                }
+
+                pos += SEC_SIZE;
+                read = rb->read(fd, sector, (size > SEC_SIZE) ? SEC_SIZE : size); // payload for next sector
+                size -= read;
+        } while (read > 0);
+        
+        rb->close(fd);
+        
+        return failures;
+}
+
+// returns the # of failures, 0 on success
+unsigned VerifyImageFile(char* filename, UINT8* pos, tImageHeader* pImageHeader, int start, int size)
+{
+        int i;
+        int fd;
+        int read; // how many for this sector
+        unsigned failures = 0;
+        
+        fd = rb->open(filename, O_RDONLY);
+        if (fd < 0)
+                return false;
+
+        // no error checking necessary here, we checked for minimum size already
+        rb->lseek(fd, start, SEEK_SET); // go to start position
+        
+        *(tImageHeader*)sector = *pImageHeader; // copy header into sector buffer
+        read = rb->read(fd, sector + sizeof(tImageHeader), SEC_SIZE - sizeof(tImageHeader)); // payload behind
+        size -= read;
+        read += sizeof(tImageHeader); // to be programmed, but not part of the file
+
+        do
+        {
+                for (i=0; i<read; i++)
+                {
+                        if (pos[i] != sector[i])
+                        {
+                                failures++;
+                        }
+                }
+
+                pos += SEC_SIZE;
+                read = rb->read(fd, sector, (size > SEC_SIZE) ? SEC_SIZE : size); // payload for next sector
+                size -= read;
+        } while (read);
+        
+        rb->close(fd);
+        
+        return failures;
+}
+
+
+/***************** User Interface Functions *****************/
+/*                 (to be changed for Player)               */
+
+#ifdef HAVE_LCD_BITMAP
+
+// helper for DoUserDialog()
+void ShowFlashInfo(tFlashInfo* pInfo, tImageHeader* pImageHeader)
+{
+        char buf[32];
+        
+        if (!pInfo->manufacturer)
+        {
+                rb->lcd_puts(0, 0, "Flash: M=?? D=??");
+        }
+        else
+        {
+                if (pInfo->size)
+                {
+                        rb->snprintf(buf, sizeof(buf), "Flash size: %d KB", pInfo->size / 1024);
+                        rb->lcd_puts(0, 0, buf);
+                }
+                else
+                {
+                        rb->lcd_puts(0, 0, "Unsupported chip");
+                }
+                
+        }
+
+        if (pImageHeader)
+        {
+                rb->snprintf(buf, sizeof(buf), "Image at %d KB", ((UINT8*)pImageHeader - FB) / 1024);
+                rb->lcd_puts(0, 1, buf);
+        }
+        else
+        {
+                rb->lcd_puts(0, 1, "No image found!");
+        }
+        
+        rb->lcd_update();
+}
+
+
+// Kind of our main function, defines the application flow.
+void DoUserDialog(void)
+{
+        tImageHeader ImageHeader;
+        tFlashInfo FlashInfo;
+        char buf[32];
+        int button;
+        int rc; // generic return code
+        UINT32 space, aligned_size, true_size;
+        UINT8* pos;
+
+        rb->lcd_setfont(FONT_SYSFIXED);
+        
+        pos = (void*)GetSecondImage();
+        rc = GetFlashInfo(&FlashInfo);
+
+        ShowFlashInfo(&FlashInfo, (void*)pos);
+        if (FlashInfo.size == 0) // no valid chip
+        {
+                rb->splash(HZ*3, 0, true, "Not flashable");
+                return; // exit
+        }
+        else if (pos == 0)
+        {
+                rb->splash(HZ*3, 0, true, "No Image");
+                return; // exit
+        }
+
+        rb->lcd_puts(0, 3, "using file:");
+        rb->lcd_puts(0, 4, FILENAME);
+        rb->lcd_puts(0, 6, "[F1] to check file");
+        rb->lcd_puts(0, 7, "other key to exit");
+        rb->lcd_update();
+        
+        button = rb->button_get(true);
+        button = rb->button_get(true);
+        
+        if (button != BUTTON_F1)
+        {
+                return;
+        }
+        
+        rb->lcd_clear_display();
+        rb->lcd_puts(0, 0, "checking...");
+        rb->lcd_update();
+        
+        space = FlashInfo.size - (pos-FB + sizeof(ImageHeader)); // size minus start
+        rc = CheckImageFile(FILENAME, space, &ImageHeader);
+        rb->lcd_puts(0, 0, "checked:");
+        switch (rc)
+        {
+        case eOK:
+                rb->lcd_puts(0, 1, "File OK.");
+                break;
+        case eNotUCL:
+                rb->lcd_puts(0, 1, "File not UCL ");
+                rb->lcd_puts(0, 2, "compressed.");
+                rb->lcd_puts(0, 3, "Use uclpack --2e");
+                rb->lcd_puts(0, 4, " --10 rockbox.bin");
+                break;
+        case eWrongAlgorithm:
+                rb->lcd_puts(0, 1, "Wrong algorithm");
+                rb->lcd_puts(0, 2, "for compression.");
+                rb->lcd_puts(0, 3, "Use uclpack --2e");
+                rb->lcd_puts(0, 4, " --10 rockbox.bin");
+                break;
+        case eFileNotFound:
+                rb->lcd_puts(0, 1, "File not found.");
+                rb->lcd_puts(0, 2, "Put this in root:");
+                rb->lcd_puts(0, 4, FILENAME);
+                break;
+        case eTooBig:
+                rb->lcd_puts(0, 1, "File too big,");
+                rb->lcd_puts(0, 2, "won't fit in chip.");
+                break;
+        case eTooSmall:
+                rb->lcd_puts(0, 1, "File too small.");
+                rb->lcd_puts(0, 2, "Incomplete?");
+                break;
+        case eReadErr:
+                rb->lcd_puts(0, 1, "File read error.");
+                break;
+        case eMultiBlocks:
+                rb->lcd_puts(0, 1, "File invalid.");
+                rb->lcd_puts(0, 2, "Blocksize");
+                rb->lcd_puts(0, 3, " too small?");
+                break;
+        default:
+                rb->lcd_puts(0, 1, "Check failed.");
+                break;
+        }
+        
+        if (rc == eOK)
+        {       // was OK
+                rb->lcd_puts(0, 6, "[F2] to program");
+                rb->lcd_puts(0, 7, "other key to exit");
+        }
+        else
+        {       // error occured
+                rb->lcd_puts(0, 6, "Any key to exit");
+        }
+        
+        rb->lcd_update();
+        
+        button = rb->button_get(true);
+        button = rb->button_get(true);
+        
+        if (button != BUTTON_F2)
+        {
+                return;
+        }
+        
+        true_size = ImageHeader.size;
+        aligned_size = ((sizeof(tImageHeader) + true_size + SECTORSIZE-1) & ~(SECTORSIZE-1)) - sizeof(tImageHeader); // round up to next flash sector
+        ImageHeader.size = aligned_size; // increase image size such that we reach the next sector
+
+        rb->lcd_clear_display();
+        rb->lcd_puts(0, 0, "Programming...");
+        rb->lcd_update();
+        
+        rc = ProgramImageFile(FILENAME, pos, &ImageHeader, UCL_HEADER, true_size);
+        if (rc)
+        {   // errors
+                rb->lcd_clear_display();
+                rb->lcd_puts(0, 0, "Error:");
+                rb->lcd_puts(0, 1, "Programming fail!");
+                rb->snprintf(buf, sizeof(buf), "%d errors", rc);
+                rb->lcd_puts(0, 2, buf);
+                rb->lcd_update();
+                button = rb->button_get(true);
+                button = rb->button_get(true);
+        }
+        
+        rb->lcd_clear_display();
+        rb->lcd_puts(0, 0, "Verifying...");
+        rb->lcd_update();
+        
+        rc = VerifyImageFile(FILENAME, pos, &ImageHeader, UCL_HEADER, true_size);
+        
+        rb->lcd_clear_display();
+        if (rc == 0)
+        {
+                rb->lcd_puts(0, 0, "Verify OK.");
+        }
+        else
+        {
+                rb->lcd_puts(0, 0, "Error:");
+                rb->lcd_puts(0, 1, "Verify fail!");
+                rb->snprintf(buf, sizeof(buf), "%d errors", rc);
+                rb->lcd_puts(0, 2, buf);
+                rb->lcd_puts(0, 3, "Use safe image");
+                rb->lcd_puts(0, 4, "if booting hangs:");
+                rb->lcd_puts(0, 5, "F1 during power-on");
+        }
+        rb->lcd_puts(0, 7, "Any key to exit");
+        rb->lcd_update();
+        
+        button = rb->button_get(true);
+        button = rb->button_get(true);
+}
+
+#else // HAVE_LCD_BITMAP
+
+// Player implementation has to go here
+void DoUserDialog(void)
+{
+}
+
+#endif // HAVE_LCD_BITMAP
+
+
+/***************** Plugin Entry Point *****************/
+
+enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
+{
+        
+        
+        /* this macro should be called as the first thing you do in the plugin.
+        it test that the api version and model the plugin was compiled for
+        matches the machine it is running on */
+        TEST_PLUGIN_API(api);
+        
+        /* if you don't use the parameter, you can do like
+        this to avoid the compiler warning about it */
+        (void)parameter;
+        
+        rb = api; /* copy to global api pointer */
+        
+        /* now go ahead and have fun! */
+        DoUserDialog();
+
+        return PLUGIN_OK;
+}