1 files changed, 182 insertions, 191 deletions

diff --git a/rbutil/jztool/src/fiiom3k.c b/rbutil/jztool/src/fiiom3k.c
index a43863c2f7..72e25a1220 100644
--- a/rbutil/jztool/src/fiiom3k.c
+++ b/rbutil/jztool/src/fiiom3k.c
@@ -20,264 +20,255 @@
  ****************************************************************************/
 
 #include "jztool.h"
+#include "jztool_private.h"
+#include "microtar.h"
+#include "ucl/ucl.h"
+#include <stdbool.h>
 #include <string.h>
 
-#define IMAGE_ADDR  0
-#define IMAGE_SIZE  (128 * 1024)
-#define SPL_OFFSET  0
-#define SPL_SIZE    (12 * 1024)
-#define BOOT_OFFSET (26 * 1024)
-#define BOOT_SIZE   (102 * 1024)
-
-int jz_fiiom3k_readboot(jz_usbdev* dev, jz_buffer** bufptr)
+static uint32_t xread32(const uint8_t* d)
 {
-    jz_buffer* buf = jz_buffer_alloc(IMAGE_SIZE, NULL);
-    if(!buf)
-        return JZ_ERR_OUT_OF_MEMORY;
-
-    int rc = jz_x1000_read_flash(dev, IMAGE_ADDR, buf->size, buf->data);
-    if(rc < 0) {
-        jz_buffer_free(buf);
-        return rc;
-    }
-
-    *bufptr = buf;
-    return JZ_SUCCESS;
+    uint32_t r = 0;
+    r |= d[0] << 24;
+    r |= d[1] << 16;
+    r |= d[2] <<  8;
+    r |= d[3] <<  0;
+    return r;
 }
 
-int jz_fiiom3k_writeboot(jz_usbdev* dev, size_t image_size, const void* image_buf)
+/* adapted from firmware/common/ucl_decompress.c */
+static jz_buffer* ucl_unpack(const uint8_t* src, uint32_t src_len,
+                             uint32_t* dst_len)
 {
-    int rc = jz_identify_fiiom3k_bootimage(image_buf, image_size);
-    if(rc < 0 || image_size != IMAGE_SIZE)
-        return JZ_ERR_BAD_FILE_FORMAT;
+    static const uint8_t magic[8] =
+        {0x00, 0xe9, 0x55, 0x43, 0x4c, 0xff, 0x01, 0x1a};
 
-    rc = jz_x1000_write_flash(dev, IMAGE_ADDR, image_size, image_buf);
-    if(rc < 0)
-        return rc;
+    jz_buffer* buffer = NULL;
 
-    return JZ_SUCCESS;
-}
+    /* make sure there are enough bytes for the header */
+    if(src_len < 18)
+        goto error;
 
-int jz_fiiom3k_patchboot(jz_context* jz, void* image_buf, size_t image_size,
-                         const void* spl_buf, size_t spl_size,
-                         const void* boot_buf, size_t boot_size)
-{
-    int rc = jz_identify_fiiom3k_bootimage(image_buf, image_size);
-    if(rc < 0) {
-        jz_log(jz, JZ_LOG_ERROR, "Boot image is invalid: %d", rc);
-        return JZ_ERR_BAD_FILE_FORMAT;
-    }
+    /* avoid memcmp for reasons of code size */
+    for(size_t i = 0; i < sizeof(magic); ++i)
+        if(src[i] != magic[i])
+            goto error;
 
-    rc = jz_identify_x1000_spl(spl_buf, spl_size);
-    if(rc < 0) {
-        jz_log(jz, JZ_LOG_ERROR, "SPL image is invalid: %d", rc);
-        return JZ_ERR_BAD_FILE_FORMAT;
-    }
+    /* read the other header fields */
+    /* uint32_t flags = xread32(&src[8]); */
+    uint8_t method = src[12];
+    /* uint8_t level = src[13]; */
+    uint32_t block_size = xread32(&src[14]);
 
-    if(spl_size > SPL_SIZE) {
-        jz_log(jz, JZ_LOG_ERROR, "SPL is too big");
-        return JZ_ERR_BAD_FILE_FORMAT;
-    }
+    /* check supported compression method */
+    if(method != 0x2e)
+        goto error;
 
-    rc = jz_identify_scramble_image(boot_buf, boot_size);
-    if(rc < 0) {
-        jz_log(jz, JZ_LOG_ERROR, "Bootloader image is invalid: %d", rc);
-        return JZ_ERR_BAD_FILE_FORMAT;
-    }
+    /* validate */
+    if(block_size < 1024 || block_size > 8*1024*1024)
+        goto error;
 
-    if(boot_size > BOOT_SIZE) {
-        jz_log(jz, JZ_LOG_ERROR, "Bootloader is too big");
-        return JZ_ERR_BAD_FILE_FORMAT;
-    }
+    src += 18;
+    src_len -= 18;
+
+    /* Calculate amount of space that we might need & allocate a buffer:
+     * - subtract 4 to account for end of file marker
+     * - each block is block_size bytes + 8 bytes of header
+     * - add one to nr_blocks to account for case where file size < block size
+     * - total size =  max uncompressed size of block * nr_blocks
+     */
+    uint32_t nr_blocks = (src_len - 4) / (8 + block_size) + 1;
+    uint32_t max_size = nr_blocks * (block_size + block_size/8 + 256);
+    buffer = jz_buffer_alloc(max_size, NULL);
+    if(!buffer)
+        goto error;
 
-    uint8_t* imgdat = (uint8_t*)image_buf;
-    memset(&imgdat[SPL_OFFSET], 0xff, SPL_SIZE);
-    memcpy(&imgdat[SPL_OFFSET], spl_buf, spl_size);
-    memset(&imgdat[BOOT_OFFSET], 0xff, BOOT_SIZE);
-    memcpy(&imgdat[BOOT_OFFSET], boot_buf, boot_size);
-    return JZ_SUCCESS;
-}
+    /* perform the decompression */
+    uint32_t dst_ilen = buffer->size;
+    uint8_t* dst = buffer->data;
+    while(1) {
+        if(src_len < 4)
+            goto error;
 
-#define IMGBUF  0
-#define SPLBUF  1
-#define BOOTBUF 2
-#define NUMBUFS 3
-#define IMGBUF_NAME  "image"
-#define SPLBUF_NAME  "spl"
-#define BOOTBUF_NAME "bootloader"
-#define FIIOM3K_INIT_WORKSTATE {0}
-
-struct fiiom3k_workstate {
-    jz_usbdev* dev;
-    jz_buffer* bufs[NUMBUFS];
-};
-
-static void fiiom3k_action_cleanup(struct fiiom3k_workstate* state)
-{
-    for(int i = 0; i < NUMBUFS; ++i)
-        if(state->bufs[i])
-            jz_buffer_free(state->bufs[i]);
+        uint32_t out_len = xread32(src); src += 4, src_len -= 4;
+        if(out_len == 0)
+            break;
 
-    if(state->dev)
-        jz_usb_close(state->dev);
-}
+        if(src_len < 4)
+            goto error;
 
-static int fiiom3k_action_loadbuf(jz_context* jz, jz_paramlist* pl,
-                                  struct fiiom3k_workstate* state, int idx)
-{
-    const char* const paramnames[] = {IMGBUF_NAME, SPLBUF_NAME, BOOTBUF_NAME};
+        uint32_t in_len = xread32(src); src += 4, src_len -= 4;
+        if(in_len > block_size || out_len > block_size ||
+           in_len == 0 || in_len > out_len)
+            goto error;
 
-    if(state->bufs[idx])
-        return JZ_SUCCESS;
+        if(src_len < in_len)
+            goto error;
 
-    const char* filename = jz_paramlist_get(pl, paramnames[idx]);
-    if(!filename) {
-        jz_log(jz, JZ_LOG_ERROR, "Missing required parameter '%s'", paramnames[idx]);
-        return JZ_ERR_OTHER;
-    }
+        if(in_len < out_len) {
+            uint32_t actual_out_len = dst_ilen;
+            int rc = ucl_nrv2e_decompress_safe_8(src, in_len, dst, &actual_out_len, NULL);
+            if(rc != UCL_E_OK)
+                goto error;
+            if(actual_out_len != out_len)
+                goto error;
+        } else {
+            for(size_t i = 0; i < in_len; ++i)
+                dst[i] = src[i];
+        }
 
-    int rc = jz_buffer_load(&state->bufs[idx], filename);
-    if(rc < 0) {
-        jz_log(jz, JZ_LOG_ERROR, "Error reading '%s' file (%d): %s", paramnames[idx], rc, filename);
-        return rc;
+        src += in_len;
+        src_len -= in_len;
+        dst += out_len;
+        dst_ilen -= out_len;
     }
 
-    return JZ_SUCCESS;
+    /* subtract leftover number of bytes to get size of compressed output */
+    *dst_len = buffer->size - dst_ilen;
+    return buffer;
+
+  error:
+    jz_buffer_free(buffer);
+    return NULL;
 }
 
-static int fiiom3k_action_setup(jz_context* jz, jz_paramlist* pl,
-                                struct fiiom3k_workstate* state)
+static int m3k_stage1(jz_usbdev* dev, jz_buffer* buf)
 {
-    const jz_device_info* info = jz_get_device_info(JZ_DEVICE_FIIOM3K);
-    if(!info)
-        return JZ_ERR_OTHER;
+    int rc = jz_usb_send(dev, 0xf4001000, buf->size, buf->data);
+    if(rc < 0)
+        return rc;
 
-    int rc = fiiom3k_action_loadbuf(jz, pl, state, SPLBUF);
+    return jz_usb_start1(dev, 0xf4001800);
+}
+
+static int m3k_stage2(jz_usbdev* dev, jz_buffer* buf)
+{
+    int rc = jz_usb_send(dev, 0x80004000, buf->size, buf->data);
     if(rc < 0)
         return rc;
 
-    jz_log(jz, JZ_LOG_DETAIL, "Open USB device %04x:%04x",
-           (unsigned int)info->vendor_id, (unsigned int)info->product_id);
-    rc = jz_usb_open(jz, &state->dev, info->vendor_id, info->product_id);
+    rc = jz_usb_flush_caches(dev);
     if(rc < 0)
         return rc;
 
-    jz_log(jz, JZ_LOG_DETAIL, "Setup device for flash access");
-    jz_buffer* splbuf = state->bufs[SPLBUF];
-    return jz_x1000_setup(state->dev, splbuf->size, splbuf->data);
+    return jz_usb_start2(dev, 0x80004000);
 }
 
-int jz_fiiom3k_install(jz_context* jz, jz_paramlist* pl)
+static int m3k_get_file(jz_context* jz, mtar_t* tar, const char* file,
+                        bool decompress, jz_buffer** buf)
 {
-    struct fiiom3k_workstate state = FIIOM3K_INIT_WORKSTATE;
+    jz_buffer* buffer = NULL;
+    mtar_header_t h;
     int rc;
 
-    rc = fiiom3k_action_loadbuf(jz, pl, &state, BOOTBUF);
-    if(rc < 0)
-        goto error;
+    rc = mtar_find(tar, file, &h);
+    if(rc != MTAR_ESUCCESS) {
+        jz_log(jz, JZ_LOG_ERROR, "can't find %s in boot file, tar error %d", file, rc);
+        return JZ_ERR_BAD_FILE_FORMAT;
+    }
 
-    rc = fiiom3k_action_setup(jz, pl, &state);
-    if(rc < 0)
-        goto error;
+    buffer = jz_buffer_alloc(h.size, NULL);
+    if(!buffer)
+        return JZ_ERR_OUT_OF_MEMORY;
 
-    jz_log(jz, JZ_LOG_DETAIL, "Reading boot image from device");
-    rc = jz_fiiom3k_readboot(state.dev, &state.bufs[IMGBUF]);
-    if(rc < 0)
-        goto error;
+    rc = mtar_read_data(tar, buffer->data, buffer->size);
+    if(rc != MTAR_ESUCCESS) {
+        jz_buffer_free(buffer);
+        jz_log(jz, JZ_LOG_ERROR, "can't read %s in boot file, tar error %d", file, rc);
+        return JZ_ERR_BAD_FILE_FORMAT;
+    }
 
-    jz_buffer* img_buf = state.bufs[IMGBUF];
-    const char* backupfile = jz_paramlist_get(pl, "backup");
-    const char* without_backup = jz_paramlist_get(pl, "without-backup");
-    if(backupfile) {
-        jz_log(jz, JZ_LOG_DETAIL, "Backup original boot image to file: %s", backupfile);
-        rc = jz_buffer_save(img_buf, backupfile);
-        if(rc < 0) {
-            jz_log(jz, JZ_LOG_ERROR, "Error saving backup image file (%d): %s", rc, backupfile);
-            goto error;
+    if(decompress) {
+        uint32_t dst_len;
+        jz_buffer* nbuf = ucl_unpack(buffer->data, buffer->size, &dst_len);
+        jz_buffer_free(buffer);
+        if(!nbuf) {
+            jz_log(jz, JZ_LOG_ERROR, "error decompressing %s in boot file", file);
+            return JZ_ERR_BAD_FILE_FORMAT;
         }
-    } else if(!without_backup || strcmp(without_backup, "yes")) {
-        jz_log(jz, JZ_LOG_ERROR, "No --backup option given and --without-backup yes not specified");
-        jz_log(jz, JZ_LOG_ERROR, "Refusing to flash a new bootloader without taking a backup");
-        goto error;
-    }
 
-    jz_log(jz, JZ_LOG_DETAIL, "Patching image with new SPL/bootloader");
-    jz_buffer* boot_buf = state.bufs[BOOTBUF];
-    jz_buffer* spl_buf = state.bufs[SPLBUF];
-    rc = jz_fiiom3k_patchboot(jz, img_buf->data, img_buf->size,
-                              spl_buf->data, spl_buf->size,
-                              boot_buf->data, boot_buf->size);
-    if(rc < 0) {
-        jz_log(jz, JZ_LOG_ERROR, "Error patching image: %d", rc);
-        goto error;
+        /* for simplicity just forget original size of buffer */
+        nbuf->size = dst_len;
+        buffer = nbuf;
     }
 
-    jz_log(jz, JZ_LOG_DETAIL, "Writing patched image to device");
-    rc = jz_fiiom3k_writeboot(state.dev, img_buf->size, img_buf->data);
-    if(rc < 0)
-        goto error;
+    *buf = buffer;
+    return JZ_SUCCESS;
+}
 
-    rc = JZ_SUCCESS;
+static int m3k_show_version(jz_context* jz, jz_buffer* info_file)
+{
+    /* Extract the version string and log it for informational purposes */
+    char* boot_version = (char*)info_file->data;
+    char* endpos = memchr(boot_version, '\n', info_file->size);
+    if(!endpos) {
+        jz_log(jz, JZ_LOG_ERROR, "invalid metadata in boot file");
+        return JZ_ERR_BAD_FILE_FORMAT;
+    }
 
-  error:
-    fiiom3k_action_cleanup(&state);
-    return rc;
+    *endpos = 0;
+    jz_log(jz, JZ_LOG_NOTICE, "Rockbox bootloader version: %s", boot_version);
+    return JZ_SUCCESS;
 }
 
-int jz_fiiom3k_backup(jz_context* jz, jz_paramlist* pl)
+/** \brief Load the Rockbox bootloader on the FiiO M3K
+ * \param dev       USB device freshly returned by jz_usb_open()
+ * \param filename  Path to the "bootloader.m3k" file
+ * \return either JZ_SUCCESS or an error code
+ */
+int jz_fiiom3k_boot(jz_usbdev* dev, const char* filename)
 {
-    struct fiiom3k_workstate state = FIIOM3K_INIT_WORKSTATE;
+    jz_buffer* spl = NULL, *bootloader = NULL, *info_file = NULL;
+    mtar_t tar;
     int rc;
 
-    const char* outfile_path = jz_paramlist_get(pl, IMGBUF_NAME);
-    if(!outfile_path) {
-        jz_log(jz, JZ_LOG_ERROR, "Missing required parameter '%s'", IMGBUF_NAME);
-        rc = JZ_ERR_OTHER;
-        goto error;
+    rc = mtar_open(&tar, filename, "r");
+    if(rc != MTAR_ESUCCESS) {
+        jz_log(dev->jz, JZ_LOG_ERROR, "cannot open file %s (tar error: %d)", filename, rc);
+        return JZ_ERR_OPEN_FILE;
     }
 
-    rc = fiiom3k_action_setup(jz, pl, &state);
-    if(rc < 0)
+    /* Extract all necessary files */
+    rc = m3k_get_file(dev->jz, &tar, "spl.m3k", false, &spl);
+    if(rc != JZ_SUCCESS)
         goto error;
 
-    rc = jz_fiiom3k_readboot(state.dev, &state.bufs[IMGBUF]);
-    if(rc < 0)
+    rc = m3k_get_file(dev->jz, &tar, "bootloader.ucl", true, &bootloader);
+    if(rc != JZ_SUCCESS)
         goto error;
 
-    rc = jz_buffer_save(state.bufs[IMGBUF], outfile_path);
-    if(rc < 0) {
-        jz_log(jz, JZ_LOG_ERROR, "Error writing '%s' file (%d): %s", IMGBUF_NAME, rc, outfile_path);
+    rc = m3k_get_file(dev->jz, &tar, "bootloader-info.txt", false, &info_file);
+    if(rc != JZ_SUCCESS)
         goto error;
-    }
-
-    rc = JZ_SUCCESS;
 
-  error:
-    fiiom3k_action_cleanup(&state);
-    return rc;
-}
-
-int jz_fiiom3k_restore(jz_context* jz, jz_paramlist* pl)
-{
-    struct fiiom3k_workstate state = FIIOM3K_INIT_WORKSTATE;
-    int rc;
-
-    rc = fiiom3k_action_loadbuf(jz, pl, &state, IMGBUF);
-    if(rc < 0)
+    /* Display the version string */
+    rc = m3k_show_version(dev->jz, info_file);
+    if(rc != JZ_SUCCESS)
         goto error;
 
-    rc = fiiom3k_action_setup(jz, pl, &state);
-    if(rc < 0)
+    /* Stage1 boot of SPL to set up hardware */
+    rc = m3k_stage1(dev, spl);
+    if(rc != JZ_SUCCESS)
         goto error;
 
-    jz_buffer* img_buf = state.bufs[IMGBUF];
-    rc = jz_fiiom3k_writeboot(state.dev, img_buf->size, img_buf->data);
-    if(rc < 0)
+    /* Need a bit of time for SPL to handle init */
+    jz_sleepms(500);
+
+    /* Stage2 boot into the bootloader's recovery menu
+     * User has to take manual action from there */
+    rc = m3k_stage2(dev, bootloader);
+    if(rc != JZ_SUCCESS)
         goto error;
 
     rc = JZ_SUCCESS;
 
   error:
-    fiiom3k_action_cleanup(&state);
+    if(spl)
+        jz_buffer_free(spl);
+    if(bootloader)
+        jz_buffer_free(bootloader);
+    if(info_file)
+        jz_buffer_free(info_file);
+    mtar_close(&tar);
     return rc;
 }