Show
Ignore:
Timestamp:
11/03/07 08:12:39 (13 years ago)
Author:
ppalmers
Message:

more echo firmware work

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/libffado/src/fireworks/fireworks_firmware.cpp

    r688 r689  
    3030#include <string> 
    3131#include <sstream> 
     32#include <iostream> 
     33#include <fstream> 
    3234 
    3335using namespace std; 
     36 
     37template <class T> 
     38bool from_string(T& t,  
     39                 const std::string& s,  
     40                 std::ios_base& (*f)(std::ios_base&)) 
     41{ 
     42  std::istringstream iss(s); 
     43  return !(iss >> f >> t).fail(); 
     44} 
    3445 
    3546// These classes provide support for reading/writing the firmware on 
    3647// echo fireworks based devices 
    3748namespace FireWorks { 
     49 
    3850IMPL_DEBUG_MODULE( Firmware, Firmware, DEBUG_LEVEL_NORMAL ); 
    3951IMPL_DEBUG_MODULE( FirmwareUtil, FirmwareUtil, DEBUG_LEVEL_NORMAL ); 
     
    4254 
    4355// some generic string generation functions 
    44 const char *Firmware::eDatTypeToString(const enum eDatType type) { 
     56const char *Firmware::eDatTypeToString(const enum Firmware::eDatType type) { 
    4557    switch (type) { 
    4658        case eDT_DspCode: 
     
    5971} 
    6072 
     73const enum Firmware::eDatType Firmware::intToeDatType(int type) { 
     74    switch (type) { 
     75        case (int)eDT_DspCode: return eDT_DspCode; 
     76        case (int)eDT_IceLynxCode: return eDT_IceLynxCode; 
     77        case (int)eDT_Data: return eDT_Data; 
     78        case (int)eDT_FPGACode: return eDT_FPGACode; 
     79        case (int)eDT_DeviceName: return eDT_DeviceName; 
     80        default: 
     81            return eDT_Invalid; 
     82    } 
     83} 
     84 
    6185Firmware::Firmware() 
     86: m_Type ( eDT_Invalid ) 
     87, m_flash_offset_address ( 0 ) 
     88, m_length_quads ( 0 ) 
     89, m_CRC32 ( 0 ) 
     90, m_checksum ( 0 ) 
     91, m_version ( 0 ) 
     92, m_append_crc ( false ) 
     93, m_footprint_quads ( 0 ) 
     94, m_data( NULL ) 
    6295{ 
    6396} 
     
    6598Firmware::~Firmware() 
    6699{ 
     100    if (m_data) delete[] m_data; 
    67101} 
    68102 
     
    72106    debugOutput(DEBUG_LEVEL_NORMAL, "Firmware from %s\n", m_filename.c_str()); 
    73107    debugOutput(DEBUG_LEVEL_NORMAL, " Type                 : %s\n", eDatTypeToString(m_Type)); 
    74     debugOutput(DEBUG_LEVEL_NORMAL, " Address Offset       : %08llX\n", m_flash_offset_address); 
    75     debugOutput(DEBUG_LEVEL_NORMAL, " Lenght (Quadlets)    : %08llX\n", m_length_quads); 
    76     debugOutput(DEBUG_LEVEL_NORMAL, " CRC 32               : %08llX\n", m_CRC32); 
    77     debugOutput(DEBUG_LEVEL_NORMAL, " Checksum             : %08llX\n", m_checksum); 
    78     debugOutput(DEBUG_LEVEL_NORMAL, " Firmware version     : %08llX\n", m_version); 
     108    if (m_Type == eDT_Invalid) return; 
     109 
     110    unsigned int version_major = (m_version & 0xFF000000) >> 24; 
     111    unsigned int version_minor = (m_version & 0x00FF0000) >> 16; 
     112    unsigned int version_build = (m_version & 0x0000FFFF); 
     113    debugOutput(DEBUG_LEVEL_NORMAL, " Address Offset       : 0x%08lX\n", m_flash_offset_address); 
     114    debugOutput(DEBUG_LEVEL_NORMAL, " Lenght (Quadlets)    : 0x%08lX\n", m_length_quads); 
     115    debugOutput(DEBUG_LEVEL_NORMAL, " CRC 32               : 0x%08lX\n", m_CRC32); 
     116    debugOutput(DEBUG_LEVEL_NORMAL, " Checksum             : 0x%08lX\n", m_checksum); 
     117    debugOutput(DEBUG_LEVEL_NORMAL, " Firmware version     : %02u.%02u.%02u (0x%08X)\n",  
     118                                    version_major, version_minor, version_build, m_version); 
    79119    debugOutput(DEBUG_LEVEL_NORMAL, " Append CRC           : %s\n", (m_append_crc?"Yes":"No")); 
    80     debugOutput(DEBUG_LEVEL_NORMAL, " Footprint (Quadlets) : %08llX\n", m_footprint_quads); 
    81  
     120    debugOutput(DEBUG_LEVEL_NORMAL, " Footprint (Quadlets) : 0x%08lX\n", m_footprint_quads); 
    82121} 
    83122 
     
    86125{ 
    87126    debugOutput(DEBUG_LEVEL_VERBOSE, "Loading firmware from file %s\n", filename.c_str()); 
    88      
    89      
     127    fstream fwfile; 
     128     
     129    debugOutput(DEBUG_LEVEL_VERBOSE, " Loading file...\n"); 
     130    fwfile.open( filename.c_str(), ios::in | ios::ate); 
     131    if ( !fwfile.is_open() ) { 
     132        debugError("Could not open file.\n"); 
     133        return false; 
     134    } 
     135    // get file size 
     136    int size; 
     137    size = (int)fwfile.tellg(); 
     138     
     139    if( size > ECHO_FIRMWARE_FILE_MAX_LENGTH_BYTES) { 
     140        debugError("File too large (%d bytes).\n", size); 
     141        return false; 
     142    } 
     143     
     144    debugOutput(DEBUG_LEVEL_VERBOSE, " Checking magic...\n"); 
     145    // read magic 
     146    if( size < ECHO_FIRMWARE_MAGIC_LENGTH_BYTES) { 
     147        debugError("File too small (%d bytes) to contain the magic header.\n", size); 
     148        return false; 
     149    } 
     150     
     151    fwfile.seekg (0, ios::beg); 
     152    getline(fwfile, m_magic); 
     153    // get rid of the DOS-Style end of line 
     154    string::size_type loc = m_magic.find( '\r' ); 
     155    if( loc != string::npos ) { 
     156        m_magic.erase(loc); 
     157    } 
     158    loc = m_magic.find( '\n' ); 
     159    if( loc != string::npos ) { 
     160        m_magic.erase(loc); 
     161    } 
     162     
     163    // check the magic 
     164    if (m_magic != ECHO_FIRMWARE_MAGIC) { 
     165        debugError("Magic was '%s' but should have been '%s'\n",  
     166                    m_magic.c_str(), ECHO_FIRMWARE_MAGIC); 
     167        return false; 
     168    } 
     169 
     170    debugOutput(DEBUG_LEVEL_VERBOSE, "   magic OK...\n"); 
     171     
     172    debugOutput(DEBUG_LEVEL_VERBOSE, " Reading header...\n"); 
     173    // read header 
     174    if( size < ECHO_FIRMWARE_MAGIC_LENGTH_BYTES + ECHO_FIRMWARE_HEADER_LENGTH_BYTES) { 
     175        debugError("File too small to contain the header.\n"); 
     176        return false; 
     177    } 
     178     
     179    for (int i=0; i < ECHO_FIRMWARE_HEADER_LENGTH_QUADLETS; i++) { 
     180        std::string buffer; 
     181        getline(fwfile, buffer); 
     182        // get rid of the DOS-Style end of line 
     183        string::size_type loc = buffer.find( '\r' ); 
     184        if( loc != string::npos ) { 
     185            buffer.erase(loc); 
     186        } 
     187        loc = buffer.find( '\n' ); 
     188        if( loc != string::npos ) { 
     189            buffer.erase(loc); 
     190        } 
     191         
     192        if (!from_string<uint32_t>(m_header[i], buffer, std::hex)) { 
     193            debugWarning("Could not convert '%s' to uint32_t\n", buffer.c_str()); 
     194            return false; 
     195        } 
     196         
     197        debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "   Header %02d: %08lX\n",  
     198                    i, m_header[i]); 
     199    } 
     200 
     201    m_Type                  = intToeDatType(m_header[0]); 
     202    m_flash_offset_address  = m_header[1]; 
     203    m_length_quads          = m_header[2]; 
     204    m_CRC32                 = m_header[3]; 
     205    m_checksum              = m_header[4]; 
     206    m_version               = m_header[5]; 
     207    m_append_crc            = m_header[6] != 0; 
     208    m_footprint_quads       = m_header[7]; 
     209    debugOutput(DEBUG_LEVEL_VERBOSE, "  header ok...\n"); 
     210 
     211    debugOutput(DEBUG_LEVEL_VERBOSE, " Reading data...\n"); 
     212    delete m_data; 
     213    m_data = new uint32_t[m_length_quads]; 
     214    for (uint32_t i=0; i < m_length_quads; i++) { 
     215        std::string buffer; 
     216        getline(fwfile, buffer); 
     217        // get rid of the DOS-Style end of line 
     218        string::size_type loc = buffer.find( '\r' ); 
     219        if( loc != string::npos ) { 
     220            buffer.erase(loc); 
     221        } 
     222        loc = buffer.find( '\n' ); 
     223        if( loc != string::npos ) { 
     224            buffer.erase(loc); 
     225        } 
     226         
     227        if (!from_string<uint32_t>(m_data[i], buffer, std::hex)) { 
     228            debugWarning("Could not convert '%s' to uint32_t\n", buffer.c_str()); 
     229            return false; 
     230        } 
     231         
     232        debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "   Data %02d: %08lX\n",  
     233                    i, m_data[i]); 
     234    } 
     235    debugOutput(DEBUG_LEVEL_VERBOSE, "  data ok...\n"); 
     236    fwfile.close(); 
     237 
    90238    m_filename =  filename; 
    91239    return false; 
     
    93241 
    94242// the firmware loader helper class 
    95 FirmwareUtil::FirmwareUtil(FireWorks::Device& p, FireWorks::Firmware& f
     243FirmwareUtil::FirmwareUtil(FireWorks::Device& p
    96244: m_Parent(p) 
    97 , m_Firmware(f) 
    98245{ 
    99246}