Sansa Connect: Clear recoverzap parameter

Clearing recoverzap parameter exists the Recovery Mode. This makes it
possible to run Rockbox on Sansa Connect without relying on original
Linux firmware.

Enable write-through cache on flash memory as write-back complicates
handling without any real benefits. The flash memory accepts commands
as series of writes at predefined addresses, so it is important that
the cache does not interfere with the writes.

Change-Id: I219f962f20953d84df43012cf16bbb16d673add8

1 files changed, 140 insertions, 0 deletions

diff --git a/bootloader/sansaconnect.c b/bootloader/sansaconnect.c
index a6559fee55..a87b23745f 100644
--- a/bootloader/sansaconnect.c
+++ b/bootloader/sansaconnect.c
@@ -33,6 +33,144 @@
 #include "power.h"
 #include "loader_strerror.h"
 
+#define FLASH_BASE              0x00100000
+#define PARAMETERS_FLASH_OFFSET 0x00010000
+#define PARAMETERS_SIZE_BYTES   0x00010000
+#define PARAMETERS_NUM          32
+
+#define FLASH_WRITE(addr, val)  *(volatile uint16_t *)(FLASH_BASE + addr) = val
+#define FLASH_READ(addr)        *(volatile uint16_t *)(FLASH_BASE + addr)
+
+#define PARAMETER_TYPE_BINARY   0xF00FB00B
+#define PARAMETER_TYPE_LONGBIN  0xBEADFEAD
+#define PARAMETER_TYPE_STRING   0xBEEFFACE
+
+typedef struct
+{
+    uint32_t magic;
+    char name[60];
+    char value[192];
+} parameter_t;
+
+/* Cache all parameters because parameters are stored on a single erase block */
+static union
+{
+    parameter_t entry[PARAMETERS_NUM];
+    /* raw consists of parameter_t array and bootloader graphics */
+    uint16_t raw[PARAMETERS_SIZE_BYTES/sizeof(uint16_t)];
+} parameters;
+
+static void parameters_load_from_flash(void)
+{
+    uint32_t offset = PARAMETERS_FLASH_OFFSET;
+    uint16_t *dst = parameters.raw;
+
+    while (offset < (PARAMETERS_FLASH_OFFSET + PARAMETERS_SIZE_BYTES))
+    {
+        *dst++ = FLASH_READ(offset);
+        offset += sizeof(uint16_t);
+    }
+}
+
+void parameters_erase(void) __attribute__ ((section(".icode")));
+void parameters_erase(void)
+{
+    uint32_t offset = PARAMETERS_FLASH_OFFSET;
+
+    while (offset < (PARAMETERS_FLASH_OFFSET + PARAMETERS_SIZE_BYTES))
+    {
+        if (FLASH_READ(offset) != 0xFFFF)
+        {
+            /* Found programmed halfword */
+            break;
+        }
+        offset += sizeof(uint16_t);
+    }
+
+    if (offset >= (PARAMETERS_FLASH_OFFSET + PARAMETERS_SIZE_BYTES))
+    {
+        /* Flash is already erased */
+        return;
+    }
+
+    /* Execute Block Erase sequence */
+    FLASH_WRITE(0xAAA, 0xAA);
+    FLASH_WRITE(0x554, 0x55);
+    FLASH_WRITE(0xAAA, 0x80);
+    FLASH_WRITE(0xAAA, 0xAA);
+    FLASH_WRITE(0x554, 0x55);
+    FLASH_WRITE(PARAMETERS_FLASH_OFFSET, 0x30);
+
+    /* Erase finishes once we read 0xFFFF on previously programmed halfword
+     * Typical block erase time is 0.7 s, maximum 15 s. Do not check the
+     * timeout here because we have to wait until the erase finishes as most
+     * of Rockbox bootloader code executes from flash.
+     */
+    do
+    {
+        /* Discard caches to force reads from memory */
+        commit_discard_idcache();
+    }
+    while (FLASH_READ(offset) != 0xFFFF);
+}
+
+void parameters_write_to_flash(void) __attribute__ ((section(".icode")));
+void parameters_write_to_flash(void)
+{
+    uint16_t *src = parameters.raw;
+    uint32_t offset = PARAMETERS_FLASH_OFFSET;
+
+    while (offset < (PARAMETERS_FLASH_OFFSET + PARAMETERS_SIZE_BYTES))
+    {
+        if (FLASH_READ(offset) != *src)
+        {
+            /* Program halfword */
+            FLASH_WRITE(0xAAA, 0xAA);
+            FLASH_WRITE(0x554, 0x55);
+            FLASH_WRITE(0xAAA, 0xA0);
+            FLASH_WRITE(offset, *src);
+
+            /* Word programming time typical is 14 us, maximum 330 us */
+            do
+            {
+                /* Discard caches to force reads from memory */
+                commit_discard_idcache();
+            }
+            while (FLASH_READ(offset) != *src);
+        }
+        offset += sizeof(uint16_t);
+        src++;
+    }
+}
+
+static void clear_recoverzap(void)
+{
+    int i;
+    bool needs_reflash = false;
+
+    parameters_load_from_flash();
+    for (i = 0; i < PARAMETERS_NUM; i++)
+    {
+        if ((parameters.entry[i].magic == PARAMETER_TYPE_STRING) &&
+            (!strcmp("recoverzap", parameters.entry[i].name)))
+        {
+            memset(&parameters.entry[i], 0xFF, sizeof(parameter_t));
+            needs_reflash = true;
+        }
+    }
+
+    if (needs_reflash)
+    {
+        int cpsr = disable_interrupt_save(IRQ_FIQ_STATUS);
+        printf("Erasing OF parameters memory");
+        parameters_erase();
+        printf("Flashing OF parameters");
+        parameters_write_to_flash();
+        printf("Cleared recoverzap parameter");
+        restore_interrupt(cpsr);
+    }
+}
+
 extern void show_logo(void);
 
 void main(void)
@@ -69,6 +207,8 @@ void main(void)
     printf("Rockbox boot loader");
     printf("Version %s", rbversion);
 
+    clear_recoverzap();
+
     ret = storage_init();
     if(ret)
         printf("SD error: %d", ret);