summaryrefslogtreecommitdiff
path: root/apps
diff options
context:
space:
mode:
Diffstat (limited to 'apps')
-rw-r--r--apps/plugins/rockbox_flash.c664
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;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-05 09:31:46 +0000