Changeset 1280

Show
Ignore:
Timestamp:
07/08/08 15:18:22 (13 years ago)
Author:
ppalmers
Message:

implement support for ECHO session blocks

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/libffado-2.0/src/fireworks/efc/efc_cmds_ioconfig.h

    r864 r1280  
    2929namespace FireWorks { 
    3030 
     31#define EFC_MAX_ISOC_MAP_ENTRIES    32 
     32typedef struct tag_efc_isoc_map 
     33{ 
     34    uint32_t    samplerate; 
     35    uint32_t    flags; 
     36 
     37    uint32_t    num_playmap_entries; 
     38    uint32_t    num_phys_out; 
     39    int32_t     playmap[ EFC_MAX_ISOC_MAP_ENTRIES ]; 
     40 
     41    uint32_t    num_recmap_entries; 
     42    uint32_t    num_phys_in; 
     43    int32_t     recmap[ EFC_MAX_ISOC_MAP_ENTRIES ]; 
     44} IsoChannelMap; 
     45 
    3146class EfcGenericIOConfigCmd : public EfcCmd 
    3247{ 
     
    4661     
    4762    virtual const char* getCmdName() const 
    48         { return "EfcGenericIOConfigCmd"; } 
     63        { return "EfcGenericIOConfigCmd"; }; 
    4964 
    50     uint32_t    m_value; 
     65    uint32_t   m_value; 
    5166 
    5267private: 
  • branches/libffado-2.0/src/fireworks/fireworks_device.cpp

    r1229 r1280  
    4040#include "libutil/PosixMutex.h" 
    4141 
     42#include "IntelFlashMap.h" 
     43 
     44#define ECHO_FLASH_ERASE_TIMEOUT_MILLISECS 2000 
     45 
    4246#include <sstream> 
    4347using namespace std; 
     
    649653 
    650654bool 
     655Device::eraseFlashBlocks(uint32_t start_address, unsigned int nb_quads) 
     656{ 
     657    uint32_t blocksize_bytes; 
     658    uint32_t blocksize_quads; 
     659    unsigned int quads_left = nb_quads; 
     660    bool success = true; 
     661 
     662    const unsigned int max_nb_tries = 10; 
     663    unsigned int nb_tries = 0; 
     664 
     665    do { 
     666        // the erase block size is fixed by the HW, and depends 
     667        // on the flash section we're in 
     668        if (start_address < MAINBLOCKS_BASE_OFFSET_BYTES) 
     669                blocksize_bytes = PROGRAMBLOCK_SIZE_BYTES; 
     670        else 
     671                blocksize_bytes = MAINBLOCK_SIZE_BYTES; 
     672        start_address &= ~(blocksize_bytes - 1); 
     673        blocksize_quads = blocksize_bytes / 4; 
     674 
     675        uint32_t verify[blocksize_quads]; 
     676 
     677        // corner case: requested to erase less than one block 
     678        if (blocksize_quads > quads_left) { 
     679            blocksize_quads = quads_left; 
     680        } 
     681 
     682        // do the actual erase 
     683        if (!eraseFlash(start_address)) { 
     684            debugWarning("Could not erase flash block at 0x%08X\n", start_address); 
     685            success = false; 
     686        } else { 
     687            // wait for the flash to become ready again 
     688            if (!waitForFlash(ECHO_FLASH_ERASE_TIMEOUT_MILLISECS)) { 
     689                debugError("Wait for flash timed out at address 0x%08X\n", start_address); 
     690                return false; 
     691            } 
     692 
     693            // verify that the block is empty as an extra precaution 
     694            if (!readFlash(start_address, blocksize_quads, verify)) { 
     695                debugError("Could not read flash block at 0x%08X\n", start_address); 
     696                return false; 
     697            } 
     698 
     699            // everything should be 0xFFFFFFFF if the erase was successful 
     700            for (unsigned int i = 0; i < blocksize_quads; i++) { 
     701                if (0xFFFFFFFF != verify[i]) { 
     702                    debugWarning("Flash erase verification failed.\n"); 
     703                    success = false; 
     704                    break; 
     705                } 
     706            } 
     707        } 
     708 
     709        if (success) { 
     710            start_address += blocksize_bytes; 
     711            quads_left -= blocksize_quads; 
     712            nb_tries = 0; 
     713        } else { 
     714            nb_tries++; 
     715        } 
     716        if (nb_tries > max_nb_tries) { 
     717            debugError("Needed too many tries to erase flash at 0x%08X\n", start_address); 
     718            return false; 
     719        } 
     720    } while (quads_left > 0); 
     721 
     722    return true; 
     723} 
     724 
     725bool 
    651726Device::waitForFlash(unsigned int msecs) 
    652727{ 
     
    678753} 
    679754 
     755uint32_t 
     756Device::getSessionBase() 
     757{ 
     758    EfcFlashGetSessionBaseCmd cmd; 
     759    if(!doEfcOverAVC(cmd)) { 
     760        debugError("Could not get session base address\n"); 
     761        return 0; // FIXME: arbitrary 
     762    } 
     763    return cmd.m_address; 
     764} 
     765 
    680766} // FireWorks 
  • branches/libffado-2.0/src/fireworks/fireworks_device.h

    r1229 r1280  
    9595     */ 
    9696    bool eraseFlash(uint32_t addr); 
     97    bool eraseFlashBlocks(uint32_t start_address, unsigned int nb_quads); 
    9798 
    9899    /** 
     
    102103     */ 
    103104    bool waitForFlash(unsigned int msecs); 
     105 
     106    /** 
     107     * @brief get the flash address of the session block 
     108     * @return session block base address 
     109     */ 
     110    uint32_t getSessionBase(); 
    104111 
    105112// Echo specific stuff 
  • branches/libffado-2.0/src/fireworks/fireworks_firmware.cpp

    r1235 r1280  
    3737#include <cstring> 
    3838 
    39 #define ECHO_FLASH_ERASE_TIMEOUT_MILLISECS 2000 
    40  
    4139#define DAT_EXTENSION "dat" 
    4240 
    4341// device id's 
    44 #define AUDIOFIRE2                     0x000af2 
    45 #define AUDIOFIRE4                     0x000af4 
    46 #define AUDIOFIRE8                     0x000af8 
    47 #define AUDIOFIRE12                    0x00af12 
    48 #define AUDIOFIRE12HD          0x0af12d 
    49 #define FWHDMI                         0x00afd1 
    50 #define ONYX400F                       0x00400f  
    51 #define ONYX1200F                      0x01200f 
    52 #define FIREWORKS8                     0x0000f8 
     42#define AUDIOFIRE2          0x000af2 
     43#define AUDIOFIRE4          0x000af4 
     44#define AUDIOFIRE8          0x000af8 
     45#define AUDIOFIRE12         0x00af12 
     46#define AUDIOFIRE12HD       0x0af12d 
     47#define FWHDMI              0x00afd1 
     48#define ONYX400F            0x00400f  
     49#define ONYX1200F           0x01200f 
     50#define FIREWORKS8          0x0000f8 
    5351 
    5452using namespace std; 
     
    418416const char *Af2Dats[] =  
    419417{ 
    420        "Fireworks3" 
     418    "Fireworks3" 
    421419}; 
    422420 
    423421const char *Af4Dats[] =  
    424422{ 
    425        "Fireworks3" 
     423    "Fireworks3" 
    426424}; 
    427425 
    428426const char *Af8Dats[] =  
    429427{ 
    430        "bootstrap", 
    431        "audiofire8", 
    432        "audiofire8_E", 
    433        "FireworksARM" 
     428    "bootstrap", 
     429    "audiofire8", 
     430    "audiofire8_E", 
     431    "FireworksARM" 
    434432}; 
    435433 
    436434const char *Af12Dats[] =  
    437435{ 
    438        "bootstrap", 
    439        "audiofire12", 
    440        "audiofire12_E", 
    441        "FireworksARM" 
     436    "bootstrap", 
     437    "audiofire12", 
     438    "audiofire12_E", 
     439    "FireworksARM" 
    442440}; 
    443441 
     
    448446    struct dat_list datlists[4] = 
    449447    { 
    450             { FW_VENDORID_ECHO, AUDIOFIRE2,    0x04010000, 1, Af2Dats }, 
    451             { FW_VENDORID_ECHO, AUDIOFIRE4,    0x04010000, 1, Af4Dats }, 
    452             { FW_VENDORID_ECHO, AUDIOFIRE8,    0x04010000, 4, Af8Dats }, 
    453             { FW_VENDORID_ECHO, AUDIOFIRE12,   0x04010000, 4, Af12Dats } 
     448            { FW_VENDORID_ECHO, AUDIOFIRE2,    0x04010000, 1, Af2Dats }, 
     449            { FW_VENDORID_ECHO, AUDIOFIRE4,    0x04010000, 1, Af4Dats }, 
     450            { FW_VENDORID_ECHO, AUDIOFIRE8,    0x04010000, 4, Af8Dats }, 
     451            { FW_VENDORID_ECHO, AUDIOFIRE12,    0x04010000, 4, Af12Dats } 
    454452    }; 
    455453 
     
    534532FirmwareUtil::eraseBlocks(uint32_t start_address, unsigned int nb_quads) 
    535533{ 
    536     uint32_t blocksize_bytes; 
    537     uint32_t blocksize_quads; 
    538     unsigned int quads_left = nb_quads; 
    539     bool success = true; 
    540  
    541     const unsigned int max_nb_tries = 10; 
    542     unsigned int nb_tries = 0; 
    543  
    544     do { 
    545         // the erase block size is fixed by the HW, and depends 
    546         // on the flash section we're in 
    547         if (start_address < MAINBLOCKS_BASE_OFFSET_BYTES) 
    548                 blocksize_bytes = PROGRAMBLOCK_SIZE_BYTES; 
    549         else 
    550                 blocksize_bytes = MAINBLOCK_SIZE_BYTES; 
    551         start_address &= ~(blocksize_bytes - 1); 
    552         blocksize_quads = blocksize_bytes / 4; 
    553  
    554         uint32_t verify[blocksize_quads]; 
    555  
    556         // corner case: requested to erase less than one block 
    557         if (blocksize_quads > quads_left) { 
    558             blocksize_quads = quads_left; 
    559         } 
    560  
    561         // do the actual erase 
    562         if (!m_Parent.eraseFlash(start_address)) { 
    563             debugWarning("Could not erase flash block at 0x%08X\n", start_address); 
    564             success = false; 
    565         } else { 
    566             // wait for the flash to become ready again 
    567             if (!m_Parent.waitForFlash(ECHO_FLASH_ERASE_TIMEOUT_MILLISECS)) { 
    568                 debugError("Wait for flash timed out at address 0x%08X\n", start_address); 
    569                 return false; 
    570             } 
    571  
    572             // verify that the block is empty as an extra precaution 
    573             if (!m_Parent.readFlash(start_address, blocksize_quads, verify)) { 
    574                 debugError("Could not read flash block at 0x%08X\n", start_address); 
    575                 return false; 
    576             } 
    577  
    578             // everything should be 0xFFFFFFFF if the erase was successful 
    579             for (unsigned int i = 0; i < blocksize_quads; i++) { 
    580                 if (0xFFFFFFFF != verify[i]) { 
    581                     debugWarning("Flash erase verification failed.\n"); 
    582                     success = false; 
    583                     break; 
    584                 } 
    585             } 
    586         } 
    587  
    588         if (success) { 
    589             start_address += blocksize_bytes; 
    590             quads_left -= blocksize_quads; 
    591             nb_tries = 0; 
    592         } else { 
    593             nb_tries++; 
    594         } 
    595         if (nb_tries > max_nb_tries) { 
    596             debugError("Needed too many tries to erase flash at 0x%08X\n", start_address); 
    597             return false; 
    598         } 
    599     } while (quads_left > 0); 
    600      
    601     return true; 
     534    return m_Parent.eraseFlashBlocks(start_address, nb_quads); 
    602535} 
    603536 
  • branches/libffado-2.0/src/SConscript

    r1213 r1280  
    137137        fireworks/efc/efc_cmds_monitor.cpp \ 
    138138        fireworks/efc/efc_cmds_ioconfig.cpp \ 
     139        fireworks/fireworks_session_block.cpp \ 
    139140        fireworks/audiofire/audiofire_device.cpp \ 
    140141' ) 
  • branches/libffado-2.0/support/firmware/fireworks-downloader.cpp

    r1235 r1280  
    2727#include "src/fireworks/fireworks_device.h" 
    2828#include "src/fireworks/fireworks_firmware.h" 
     29#include "src/fireworks/fireworks_session_block.h" 
    2930 
    3031#include "libieee1394/configrom.h" 
     
    4950// arg parsing 
    5051//////////////////////////////////////////////// 
    51 const char *argp_program_version = "fireworks-downloader 0.2"; 
     52const char *argp_program_version = "fireworks-downloader 0.3"; 
    5253const char *argp_program_bug_address = "<ffado-devel@lists.sf.net>"; 
    5354const char *doc = "fireworks-downloader -- firmware downloader application for ECHO Fireworks devices\n\n" 
     
    6768                    "              Verify that the firmware contained in the device corresponds\n" 
    6869                    "              to the one contained in FILE\n" 
     70                    "           session_display\n" 
     71                    "              show information about the session on the device\n" 
     72                    "           session_info FILE\n" 
     73                    "              show information about the session in FILE\n" 
     74                    "           session_download FILE\n" 
     75                    "              Download the session content from the device to FILE\n" 
     76                    "           session_upload FILE\n" 
     77                    "              Upload the session from FILE to the device\n" 
    6978                    ; 
    7079 
     
    148157        f.dumpData(); 
    149158        return 0; 
     159    } else if ( strcmp( args->args[0], "session_info" ) == 0 ) { 
     160        if (!args->args[1] ) { 
     161            printMessage("FILE argument is missing\n"); 
     162            return -1; 
     163        } 
     164        std::string str( args->args[1] ); 
     165 
     166        // load the file 
     167        Session s = Session(); 
     168        s.setVerboseLevel( args->verbose ); 
     169 
     170        if (!s.loadFromFile(str)) { 
     171            printMessage("Could not load session\n"); 
     172            return -1; 
     173        } 
     174        s.show(); 
     175        return 0; 
    150176    } else if ( strcmp( args->args[0], "list" ) == 0 ) { 
    151177        printDeviceList(); 
     
    169195        ConfigRom configRom(service, i); 
    170196        configRom.initialize(); 
    171          
    172197        if (configRom.getGuid() == guid) { 
    173198            node_id = configRom.getNodeId(); 
     
    382407            printMessage(" => Verify successful. Firmware upload successful.\n"); 
    383408        } 
     409    } else if ( strcmp( args->args[0], "session_display" ) == 0 ) { 
     410        // load the session 
     411        Session s = Session(); 
     412        s.setVerboseLevel( args->verbose ); 
     413 
     414        if (!s.loadFromDevice(*dev)) { 
     415            printMessage("Could not load session\n"); 
     416            return -1; 
     417        } 
     418        s.show(); 
     419    } else if ( strcmp( args->args[0], "session_download" ) == 0 ) { 
     420        if (!args->args[1] ) { 
     421            printMessage("FILE argument is missing\n"); 
     422            delete dev; 
     423            return -1; 
     424        } 
     425        std::string str( args->args[1] ); 
     426 
     427        printMessage("Downloading session to file: %s\n", str.c_str()); 
     428 
     429        printMessage(" loading session...\n"); 
     430        // load the session 
     431        Session s = Session(); 
     432        s.setVerboseLevel( args->verbose ); 
     433 
     434        if (!s.loadFromDevice(*dev)) { 
     435            printMessage("Could not load session from device\n"); 
     436            return -1; 
     437        } 
     438 
     439        printMessage(" saving session...\n"); 
     440        if (!s.saveToFile(str)) { 
     441            printMessage("Could not save session to file\n"); 
     442            return -1; 
     443        } 
     444    } else if ( strcmp( args->args[0], "session_upload" ) == 0 ) { 
     445        if (!args->args[1] ) { 
     446            printMessage("FILE argument is missing\n"); 
     447            delete dev; 
     448            return -1; 
     449        } 
     450        std::string str( args->args[1] ); 
     451 
     452        printMessage("Uploading session from file: %s\n", str.c_str()); 
     453 
     454        printMessage(" loading session...\n"); 
     455        // load the session 
     456        Session s = Session(); 
     457        s.setVerboseLevel( args->verbose ); 
     458        if (!s.loadFromFile(str)) { 
     459            printMessage("Could not load session from file\n"); 
     460            return -1; 
     461        } 
     462 
     463        printMessage(" saving session...\n"); 
     464        if (!s.saveToDevice(*dev)) { 
     465            printMessage("Could not save session to device\n"); 
     466            return -1; 
     467        } 
     468 
    384469    }  else { 
    385470        printMessage("Unknown operation\n");