Changeset 1011

Timestamp:

04/23/08 10:10:02 (4 years ago)

Author:

ppalmers

Message:

finish ECHO firmware tools

Files:

• trunk/libffado/src/fireworks/efc/efc_avc_cmd.cpp (modified) (1 diff)
• trunk/libffado/src/fireworks/efc/efc_cmds_flash.cpp (modified) (3 diffs)
• trunk/libffado/src/fireworks/fireworks_device.cpp (modified) (2 diffs)
• trunk/libffado/src/fireworks/fireworks_device.h (modified) (1 diff)
• trunk/libffado/src/fireworks/fireworks_firmware.cpp (modified) (10 diffs)
• trunk/libffado/src/fireworks/fireworks_firmware.h (modified) (5 diffs)
• trunk/libffado/support/firmware/downloader.cpp (modified) (2 diffs)
• trunk/libffado/support/firmware/downloader.h (modified) (2 diffs)
• trunk/libffado/support/firmware/fireworks-downloader.cpp (modified) (6 diffs)

trunk/libffado/src/fireworks/efc/efc_avc_cmd.cpp

@@ -80 +80 @@
-    result &= de.read(&m_dummy_2);
-
+    if(!result) {
+        debugWarning("AV/C deserialization failed\n");
+        return false;
+    }
+
-    result &= m_cmd->deserialize( de );
-    

trunk/libffado/src/fireworks/efc/efc_cmds_flash.cpp

@@ -59 +59 @@
-
-    result &= EfcCmd::deserialize ( de );
-
-    EFC_DESERIALIZE_AND_SWAP(de, &m_address, result);
-
-    return result;
@@ -112 +110 @@
-    }
-    for (unsigned int i=0; i < m_nb_quadlets; i++) {
-        // FIXME: do we have to swap?
-        EFC_DESERIALIZE_AND_SWAP(de, &m_data[i], result);
-        // or not?
-        //result &= de.read(&m_data[i]);
-    }
-    return result;
@@ -161 +156 @@
-
-    for (unsigned int i=0; i < m_nb_quadlets; i++) {
-
-
-
+
-    }
-    return result;

trunk/libffado/src/fireworks/fireworks_device.cpp

@@ -501 +501 @@
-
-bool
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    if(len <= 0 || 0xFFFFFFFF - len*4 < start) {
@@ -516 +528 @@
-    uint32_t *target_buffer = buffer;
-
+    EfcFlashWriteCmd cmd;
+    // write EFC_FLASH_SIZE_BYTES at a time
+    for(start_addr = start; start_addr < stop_addr; start_addr += EFC_FLASH_SIZE_BYTES) {
+        cmd.m_address = start_addr;
+        unsigned int quads_to_write = (stop_addr - start_addr)/4;
+        if (quads_to_write > EFC_FLASH_SIZE_QUADS) {
+            quads_to_write = EFC_FLASH_SIZE_QUADS;
+        }
+        cmd.m_nb_quadlets = quads_to_write;
+        for(unsigned int i=0; i<quads_to_write; i++) {
+            cmd.m_data[i] = *target_buffer;
+            target_buffer++;
+        }
+        if(!doEfcOverAVC(cmd)) {
+            debugError("Flash write failed for block 0x%08X (%d quadlets)\n", start_addr, quads_to_write);
+            return false;
+        }
+    }
+    return true;
+}
+
+bool
+Device::readFlash(uint32_t start, uint32_t len, uint32_t* buffer) {
+
+    if(len <= 0 || 0xFFFFFFFF - len*4 < start) {
+        debugError("bogus start/len: 0x%08X / %u\n", start, len);
+        return false;
+    }
+    if(start & 0x03) {
+        debugError("start address not quadlet aligned: 0x%08X\n", start);
+        return false;
+    }
+
+    uint32_t start_addr = start;
+    uint32_t stop_addr = start + len*4;
+    uint32_t *target_buffer = buffer;
+
-    EfcFlashReadCmd cmd;
-    // read EFC_FLASH_SIZE_BYTES at a time
-    for(start_addr = start; start_addr < stop_addr; start_addr += EFC_FLASH_SIZE_BYTES) {
-        cmd.m_address = start_addr;
-        unsigned int quads_to_read = (stop_addr - start_addr)/4;
-        if (quads_to_read > EFC_FLASH_SIZE_QUADS) {
-            quads_to_read = EFC_FLASH_SIZE_QUADS;
-        }
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            return false;
-        }
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            return false;
-        }
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-

trunk/libffado/src/fireworks/fireworks_device.h

@@ -73 +73 @@
-    bool readFlash(uint32_t start, uint32_t len, uint32_t* buffer);
-
+    /**
+     * @brief Write flash
+     * @param start start address
+     * @param len length in quadlets (4 bytes)
+     * @param buffer target buffer (should be 'len*4' bytes long)
+     * @return true if successful
+     */
+    bool writeFlash(uint32_t start, uint32_t len, uint32_t* buffer);
+
+    /**
+     * @brief (un)lock the flash
+     * @param lock true=locked, false=unlocked
+     * @return true if successful
+     */
+    bool lockFlash(bool lock);
+    /**
+     * @brief erase flash block
+     * @param addr address of block to erase
+     * @return true if successful
+     */
+    bool eraseFlash(uint32_t addr);
+
+    /**
+     * @brief wait until the device indicates the flash memory is ready
+     * @param msecs time to wait before timeout
+     * @return true if the flash is ready, false if timeout
+     */
+    bool waitForFlash(unsigned int msecs);
+
-// Echo specific stuff
-private:

trunk/libffado/src/fireworks/fireworks_firmware.cpp

@@ -28 +28 @@
-#include "efc/efc_cmds_flash.h"
-
+#include "libieee1394/configrom.h"
+#include "libieee1394/vendor_model_ids.h"
+
-#include <string>
-#include <sstream>
@@ -33 +36 @@
-#include <fstream>
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-using namespace std;
@@ -362 +378 @@
-}
-
+uint32_t
+Firmware::getWriteDataLen() {
+    uint32_t retval = 0;
+    if((m_append_crc != 0) && (m_length_quads < m_footprint_quads)) {
+        retval += m_footprint_quads;
+    } else {
+        retval += m_length_quads;
+    }
+    return retval;
+}
+
+bool
+Firmware::getWriteData(uint32_t *buff) {
+    // copy the payload data
+    memcpy(buff, m_data, m_length_quads*4);
+    // if necessary, add crc/version
+    if((m_append_crc != 0) && (m_length_quads < m_footprint_quads)) {
+        debugOutput(DEBUG_LEVEL_VERBOSE, "appending CRC and version\n");
+        buff[m_footprint_quads - 1] = m_CRC32;
+        buff[m_footprint_quads - 2] = m_version;
+    }
+    return true;
+}
+
-void
-Firmware::dumpData()
@@ -367 +407 @@
-    debugWarning("-- char dump --");
-    hexDump((unsigned char*)m_data, m_length_quads*4);
-
+/*
-    debugWarning("-- quadlet dump --");
-
-
-
+
+
+
+
-
-// the firmware loader helper class
+char *Af2Dats[] = 
+{
+        "Fireworks3"
+};
+
+char *Af4Dats[] = 
+{
+        "Fireworks3"
+};
+
+char *Af8Dats[] = 
+{
+        "bootstrap",
+        "audiofire8",
+        "audiofire8_E",
+        "FireworksARM"
+};
+
+char *Af12Dats[] = 
+{
+        "bootstrap",
+        "audiofire12",
+        "audiofire12_E",
+        "FireworksARM"
+};
+
-FirmwareUtil::FirmwareUtil(FireWorks::Device& p)
-: m_Parent(p)
-{
+
+    struct dat_list datlists[4] =
+    {
+            { FW_VENDORID_ECHO, AUDIOFIRE2,     0x04010000, 1, Af2Dats },
+            { FW_VENDORID_ECHO, AUDIOFIRE4,     0x04010000, 1, Af4Dats },
+            { FW_VENDORID_ECHO, AUDIOFIRE8,     0x04010000, 4, Af8Dats },
+            { FW_VENDORID_ECHO, AUDIOFIRE12,    0x04010000, 4, Af12Dats }
+    };
+
+    assert(sizeof(datlists) <= sizeof(m_datlists));
+    memset(&m_datlists, 0, sizeof(m_datlists));
+    memcpy(&m_datlists, &datlists, sizeof(datlists));
-}
-
-FirmwareUtil::~FirmwareUtil()
-{
+}
+
+bool
+FirmwareUtil::isValidForDevice(Firmware f)
+{
+    std::string src = f.getSourceString();
+
+    uint32_t vendor = m_Parent.getConfigRom().getNodeVendorId();
+    uint32_t model = m_Parent.getConfigRom().getModelId();
+
+    for (unsigned int i=0; i<ECHO_FIRMWARE_NUM_BOXTYPES; i++) {
+        if(m_datlists[i].boxtype == model
+           && m_datlists[i].vendorid == vendor)
+        {
+            for(int j=0; j<m_datlists[i].count; j++) {
+                std::string cmpstring = m_datlists[i].filenames[j];
+                cmpstring += ".dat";
+                std::string::size_type loc = src.find( cmpstring, 0 );
+                if( loc != std::string::npos ) {
+                    debugOutput(DEBUG_LEVEL_VERBOSE, "found filename\n");
+                    return true;
+                    break;
+                 }
+            }
+        }
+    }
+    debugOutput(DEBUG_LEVEL_VERBOSE, "file not for this device\n");
+    return false;
-}
-
@@ -407 +514 @@
-
-bool
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -439 +533 @@
-FirmwareUtil::eraseBlocks(uint32_t start_address, unsigned int nb_quads)
-{
-    EfcFlashEraseCmd eraseCmd;
-    uint32_t blocksize_bytes;
-    uint32_t blocksize_quads;
@@ -458 +551 @@
-        blocksize_quads = blocksize_bytes / 4;
-
+        uint32_t verify[blocksize_quads];
+
-        // corner case: requested to erase less than one block
-        if (blocksize_quads > quads_left) {
@@ -464 +559 @@
-
-        // do the actual erase
-
-
+
-            debugWarning("Could not erase flash block at 0x%08X\n", start_address);
-            success = false;
-        } else {
+            // wait for the flash to become ready again
+            if (!m_Parent.waitForFlash(ECHO_FLASH_ERASE_TIMEOUT_MILLISECS)) {
+                debugError("Wait for flash timed out at address 0x%08X\n", start_address);
+                return false;
+            }
+
-            // verify that the block is empty as an extra precaution
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-                }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-        }
-
@@ -504 +593 @@
-        }
-        if (nb_tries > max_nb_tries) {
-
+\n
-            return false;
-        }
@@ -511 +600 @@
-    return true;
-}
-
-
-void

trunk/libffado/src/fireworks/fireworks_firmware.h

@@ -51 +51 @@
-#define ECHO_FIRMWARE_FILE_MAX_LENGTH_QUADLETS  ((384 * 1024) / 4)
-#define ECHO_FIRMWARE_FILE_MAX_LENGTH_BYTES     (ECHO_FIRMWARE_FILE_MAX_LENGTH_QUADLETS * 12 + ECHO_FIRMWARE_HEADER_LENGTH_BYTES)
+
+#define ECHO_FIRMWARE_NUM_BOXTYPES  4
-
-class Firmware
@@ -76 +78 @@
-    virtual bool isValid() {return m_valid;};
-
+    virtual std::string getSourceString() {return m_source;};
+
-    /**
-     * @brief compare two firmwares
@@ -94 +98 @@
-     */
-    virtual uint32_t getLength() {return m_length_quads;};
+
+    /**
+     * @brief get length of data to be written to the device (in quadlets)
+     * @return length (in quadlets)
+     */
+    virtual uint32_t getWriteDataLen();
+    /**
+     * @brief prepares data to be written to the device
+     * @param buff buffer to copy data into. should be at least getWriteDataLen() quadlets.
+     * @return true if successful
+     */
+    virtual bool getWriteData(uint32_t *buff);
-
-    virtual void show();
@@ -143 +159 @@
-    Firmware getFirmwareFromDevice(uint32_t start, uint32_t length);
-
-
-
-
-
-
+
+
+
+
+
+
+
-
-    /**
@@ -157 +175 @@
-    bool eraseBlocks(unsigned int address, unsigned int nb_quads);
-
+    /**
+     * @brief checks whether a firmware is valid for this device
+     * @param f firmware to check
+     * @return true if valid, false if not
+     */
+    bool isValidForDevice(Firmware f);
+
-protected:
-    FireWorks::Device&          m_Parent;
+
+private:
+    struct dat_list
+    {
+        uint32_t    vendorid;
+        uint32_t    boxtype;
+        uint32_t    minversion;
+        int         count;
+        char        **filenames;
+    };
+
+    struct dat_list m_datlists[ECHO_FIRMWARE_NUM_BOXTYPES];
+
-private:
-    DECLARE_DEBUG_MODULE;

trunk/libffado/support/firmware/downloader.cpp

@@ -1 +1 @@
-/*
- * Copyright (C) 2005-2008 by Daniel Wagner
+ * Copyright (C) 2005-2008 by Pieter Palmers
- *
- * This file is part of FFADO
@@ -79 +80 @@
-        }
-        break;
+    case 'm':
+        errno = 0;
+        arguments->magic = strtoll(arg, &tail, 0);
+        if (errno) {
+            debugError("argument parsing failed: %s\n",
+                       strerror(errno));
+            return errno;
+        }
+        break;
-    case 'f':
-        arguments->force = 1;

trunk/libffado/support/firmware/downloader.h

@@ -1 +1 @@
-/*
- * Copyright (C) 2005-2008 by Daniel Wagner
+ * Copyright (C) 2005-2008 by Pieter Palmers
- *
- * This file is part of FFADO
@@ -45 +46 @@
-    int   no_bootloader_restart;
-    uint64_t guid;
+    uint64_t magic;
-};
-

trunk/libffado/support/firmware/fireworks-downloader.cpp

@@ -39 +39 @@
-#include <string.h>
-#include <string>
+
+#define MAGIC_THAT_SAYS_I_KNOW_WHAT_IM_DOING 0x001807198000LL
-
-using namespace FireWorks;
@@ -71 +73 @@
-    {"guid",      'g', "GUID",      0,  "GUID of the target device" },
-    {"port",      'p', "PORT",      0,  "Port to use" },
+    {"magic",     'm', "MAGIC",     0,  "A magic number you have to obtain before this code will work." 
+                                        "Specifying it means that you accept the risks that come with this tool."},
-    { 0 }
-};
@@ -95 +99 @@
-        argp_help(argp, stderr, ARGP_HELP_USAGE | ARGP_HELP_LONG | ARGP_HELP_DOC, argv[0]);
-        exit(-1);
+    }
+
+    if(args->magic != MAGIC_THAT_SAYS_I_KNOW_WHAT_IM_DOING) {
+        printMessage("Magic number not correct. Please specify the correct magic using the '-m' option.\n");
+        printMessage("Manipulating firmware can cause your device to magically stop working (a.k.a. 'bricking').\n");
+        printMessage("Specifying the magic number indicates that you accept the risks involved\n");
+        printMessage("with using this tool. The magic number can be found in the source code.\n");
+        return -1;
+    } else {
+        printMessage("YOU HAVE SPECIFIED THE CORRECT MAGIC NUMBER.\n");
+        printMessage("HENCE YOU ACCEPT THE RISKS INVOLVED.\n");
-    }
-
@@ -194 +209 @@
-        return -1;
-    }
+    dev->setVerboseLevel(args->verbose);
-
-    if ( strcmp( args->args[0], "display" ) == 0 ) {
@@ -227 +243 @@
-        f.setVerboseLevel( args->verbose );
-        f.show();
+        f.dumpData();
-        printMessage("Saving to file not yet supported.\n");
-    } else if (strcmp( args->args[0], "verify" ) == 0) {
@@ -272 +289 @@
-            printMessage(" => Verify successful. Device content identical to file content.\n");
-        }
-
-
+
+
+
+
+
+
+
+
-        // create the firmware util class
-        FirmwareUtil util = FirmwareUtil(*dev);
-        util.setVerboseLevel( args->verbose );
-
+        printMessage("Uploading %s to device\n", str.c_str());
+
+        printMessage(" loading file...\n");
+        // load the file
+        Firmware ref = Firmware();
+        ref.setVerboseLevel( args->verbose );
+        
+        if (!ref.loadFile(str)) {
+            printMessage("  Could not load firmware from file\n");
+            delete dev;
+            return -1;
+        }
+
+        printMessage(" checking file...\n");
+        if(!ref.isValid()) {
+            printMessage("  Firmware not valid\n");
+            delete dev;
+            return -1;
+        }
+
+        if(!util.isValidForDevice(ref)) {
+            printMessage("  Firmware not valid for this device\n");
+            delete dev;
+            return -1;
+        }
+        printMessage("  seems to be valid firmware for this device...\n");
+
+        // get the flash position from the loaded file
+        uint32_t start_addr = ref.getAddress();
+        uint32_t len = ref.getLength();
+
+        printMessage(" lock flash...\n");
+        if (!dev->lockFlash(true)) {
+            printMessage("  Could not lock flash\n");
+            delete dev;
+            return -1;
+        }
+
+        printMessage(" erasing memory...\n");
+        if (!util.eraseBlocks(start_addr, len)) {
+            printMessage("  Could not erase memory\n");
+            delete dev;
+            return -1;
+        }
+
+        printMessage(" uploading to device...\n");
+        if (!util.writeFirmwareToDevice(ref)) {
+            printMessage("  Could not write firmware to device\n");
+            delete dev;
+            return -1;
+        }
+
+        printMessage(" unlock flash...\n");
+        if (!dev->lockFlash(false)) {
+            printMessage("  Could not unlock flash\n");
+            delete dev;
+            return -1;
+        }
+
+        // now verify
+        printMessage(" verify...\n");
+
+
+        printMessage("  reading device...\n");
+        // read the corresponding part of the device
+        Firmware f = util.getFirmwareFromDevice(start_addr, len);
+        f.setVerboseLevel( args->verbose );
+        f.show();
+        
+        printMessage("  comparing...\n");
+        // compare the two images
+        if(!(f == ref)) {
+            printMessage(" => Verify failed. Firmware upload failed.\n");
+            delete dev;
+            return -1;
+        } else {
+            printMessage(" => Verify successful. Firmware upload successful.\n");
+        }
-    }  else {
-        printMessage("Unknown operation\n");