Show
Ignore:
Timestamp:
09/09/07 12:04:35 (16 years ago)
Author:
ppalmers
Message:

- Introduce a generic infrastructure for FFADODevices to present the clock sources they support and their state
- Implement this infrastructure for BeBoB devices
- Implement this infrastructure for ECHO Fireworks devices

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/libffado/src/fireworks/audiofire/audiofire_device.h

    r587 r639  
    3333 
    3434class AudioFire : public FireWorks::Device { 
     35 
    3536public: 
    3637    AudioFire( Ieee1394Service& ieee1394Service, 
  • trunk/libffado/src/fireworks/efc/efc_cmd.h

    r629 r639  
    4545#define EFC_CAT_COUNT                   10 
    4646 
     47// Commands for the EFC_CAT_HARDWARE_INFO category 
     48#define EFC_CMD_HW_HWINFO_GET_CAPS      0 
     49#define EFC_CMD_HW_GET_POLLED           1 
     50#define EFC_CMD_HW_SET_EFR_ADDRESS      2 
     51#define EFC_CMD_HW_READ_SESSION_BLOCK   3 
     52#define EFC_CMD_HW_GET_DEBUG_INFO       4 
     53#define EFC_CMD_HW_SET_DEBUG_TRACKING   5 
     54#define EFC_CMD_HW_COUNT                6 
     55 
     56// Commands for the EFC_CAT_HARDWARE_CONTROL category 
     57#define EFC_CMD_HWCTRL_SET_CLOCK        0 
     58#define EFC_CMD_HWCTRL_GET_CLOCK        1 
     59#define EFC_CMD_HWCTRL_BSX_HANDSHAKE    2 
     60#define EFC_CMD_HWCTRL_CHANGE_FLAGS     3 
     61#define EFC_CMD_HWCTRL_GET_FLAGS        4 
     62#define EFC_CMD_HWCTRL_IDENTIFY         5 
     63#define EFC_CMD_HWCTRL_RECONNECT_PHY    6 
     64 
    4765// size of the header 
    4866#define EFC_HEADER_LENGTH_QUADLETS      ((sizeof(uint32_t) + sizeof(struct EfcCmd::efc_header))/4) 
     
    5371      *(__value__)=ntohl(*(__value__)); } \ 
    5472 
     73 
     74// specifiers for the flags field 
     75#define EFC_CMD_HW_DYNADDR_SUPPORTED                1 
     76#define EFC_CMD_HW_MIRRORING_SUPPORTED              2 
     77#define EFC_CMD_HW_SPDIF_COAX_SUPPORTED             3 
     78#define EFC_CMD_HW_SPDIF_AESEBUXLR_SUPPORTED        4 
     79#define EFC_CMD_HW_HAS_DSP                          5 
     80#define EFC_CMD_HW_HAS_FPGA                         6 
     81#define EFC_CMD_HW_HAS_PHANTOM                      7 
     82 
     83#define EFC_CMD_HW_CHECK_FLAG(__val__,__flag__) \ 
     84    (((__val__) & (1<<(__flag__))) != 0) 
     85#define EFC_CMD_HW_TO_FLAG(__val__) \ 
     86    (1<<(__val__)) 
     87 
     88// Clock sources 
     89#define EFC_CMD_HW_CLOCK_INTERNAL                   0 
     90#define EFC_CMD_HW_CLOCK_SYTMATCH                   1 
     91#define EFC_CMD_HW_CLOCK_WORDCLOCK                  2 
     92#define EFC_CMD_HW_CLOCK_SPDIF                      3 
     93#define EFC_CMD_HW_CLOCK_ADAT_1                     4 
     94#define EFC_CMD_HW_CLOCK_ADAT_2                     5 
     95#define EFC_CMD_HW_CLOCK_COUNT                      6 
     96 
     97#define EFC_CMD_HW_CLOCK_UNSPECIFIED       0xFFFFFFFF 
     98 
     99// MIDI flags 
     100#define EFC_CMD_HW_MIDI_IN_1                        8 
     101#define EFC_CMD_HW_MIDI_OUT_1                       9 
     102#define EFC_CMD_HW_MIDI_IN_2                       10 
     103#define EFC_CMD_HW_MIDI_OUT_2                      11 
     104 
     105// Channel types 
     106#define EFC_CMD_HW_CHANNEL_TYPE_ANALOG              0 
     107#define EFC_CMD_HW_CHANNEL_TYPE_SPDIF               1 
     108#define EFC_CMD_HW_CHANNEL_TYPE_ADAT                2 
     109#define EFC_CMD_HW_CHANNEL_TYPE_SPDIF_OR_ADAT       3 
     110#define EFC_CMD_HW_CHANNEL_TYPE_ANALOG_MIRRORING    4 
     111#define EFC_CMD_HW_CHANNEL_TYPE_HEADPHONES          5 
     112#define EFC_CMD_HW_CHANNEL_TYPE_I2S                 6 
    55113 
    56114namespace FireWorks { 
  • trunk/libffado/src/fireworks/efc/efc_cmds_hardware.cpp

    r629 r639  
    3333EfcHardwareInfoCmd::EfcHardwareInfoCmd() 
    3434: EfcCmd(EFC_CAT_HARDWARE_INFO, EFC_CMD_HW_HWINFO_GET_CAPS) 
     35, m_nb_out_groups( 0 ) 
     36, m_nb_in_groups( 0 ) 
    3537{} 
    3638 
     
    169171EfcPolledValuesCmd::EfcPolledValuesCmd() 
    170172: EfcCmd(EFC_CAT_HARDWARE_INFO, EFC_CMD_HW_GET_POLLED) 
     173, m_nb_output_meters ( 0 ) 
     174, m_nb_input_meters ( 0 ) 
    171175{} 
    172176 
     
    195199     
    196200    EFC_DESERIALIZE_AND_SWAP(de, &m_detect_spdif, result); 
    197     EFC_DESERIALIZE_AND_SWAP(de, &m_detect_spdif, result);     
     201    EFC_DESERIALIZE_AND_SWAP(de, &m_detect_adat, result); 
    198202    EFC_DESERIALIZE_AND_SWAP(de, &m_reserved3, result); 
    199203    EFC_DESERIALIZE_AND_SWAP(de, &m_reserved4, result); 
    200204 
    201205    EFC_DESERIALIZE_AND_SWAP(de, &m_nb_output_meters, result); 
    202     EFC_DESERIALIZE_AND_SWAP(de, &m_nb_input_meters, result);     
     206    EFC_DESERIALIZE_AND_SWAP(de, &m_nb_input_meters, result); 
    203207    EFC_DESERIALIZE_AND_SWAP(de, &m_reserved5, result); 
    204208    EFC_DESERIALIZE_AND_SWAP(de, &m_reserved6, result); 
  • trunk/libffado/src/fireworks/efc/efc_cmds_hardware.h

    r629 r639  
    3232#define HWINFO_MAX_CAPS_GROUPS      8 
    3333#define POLLED_MAX_NB_METERS        100 
    34  
    35 // Commands for the EFC_CAT_HARDWARE_INFO category 
    36 #define EFC_CMD_HW_HWINFO_GET_CAPS      0 
    37 #define EFC_CMD_HW_GET_POLLED           1 
    38 #define EFC_CMD_HW_SET_EFR_ADDRESS      2 
    39 #define EFC_CMD_HW_READ_SESSION_BLOCK   3 
    40 #define EFC_CMD_HW_GET_DEBUG_INFO       4 
    41 #define EFC_CMD_HW_SET_DEBUG_TRACKING   5 
    42 #define EFC_CMD_HW_COUNT                6 
    43  
    44  
    4534 
    4635class EfcHardwareInfoCmd : public EfcCmd 
  • trunk/libffado/src/fireworks/fireworks_device.cpp

    r629 r639  
    2626#include "efc/efc_cmd.h" 
    2727#include "efc/efc_cmds_hardware.h" 
     28#include "efc/efc_cmds_hardware_ctrl.h" 
    2829 
    2930#include "audiofire/audiofire_device.h" 
     
    4041                            std::auto_ptr<ConfigRom>( configRom )) 
    4142    : GenericAVC::AvDevice( ieee1394Service, configRom) 
     43    , m_efc_discovery_done ( false ) 
    4244{ 
    4345    debugOutput( DEBUG_LEVEL_VERBOSE, "Created FireWorks::Device (NodeID %d)\n", 
    4446                 getConfigRom().getNodeId() ); 
     47    pthread_mutex_init( &m_polled_mutex, 0 ); 
    4548} 
    4649 
     
    5356{ 
    5457    debugOutput(DEBUG_LEVEL_VERBOSE, "This is a FireWorks::Device\n"); 
    55 //     GenericAVC::AvDevice::showDevice(); 
    56  
     58    GenericAVC::AvDevice::showDevice(); 
     59
     60 
     61 
     62bool 
     63Device::probe( ConfigRom& configRom ) 
     64
     65    unsigned int vendorId = configRom.getNodeVendorId(); 
     66    unsigned int modelId = configRom.getModelId(); 
     67 
     68    GenericAVC::VendorModel vendorModel( SHAREDIR "/ffado_driver_fireworks.txt" ); 
     69    if ( vendorModel.parse() ) { 
     70        vendorModel.printTable(); 
     71        return vendorModel.isPresent( vendorId, modelId ); 
     72    } 
     73 
     74    return false; 
     75
     76 
     77bool 
     78Device::discover() 
     79
     80    unsigned int vendorId = m_pConfigRom->getNodeVendorId(); 
     81    unsigned int modelId = m_pConfigRom->getModelId(); 
     82 
     83    GenericAVC::VendorModel vendorModel( SHAREDIR "/ffado_driver_fireworks.txt" ); 
     84    if ( vendorModel.parse() ) { 
     85        m_model = vendorModel.find( vendorId, modelId ); 
     86    } 
     87 
     88    if (!GenericAVC::VendorModel::isValid(m_model)) { 
     89        return false; 
     90    } 
     91    debugOutput( DEBUG_LEVEL_VERBOSE, "found %s %s\n", 
     92            m_model.vendor_name.c_str(), m_model.model_name.c_str()); 
     93 
     94    // get the info from the EFC 
     95    if ( !discoverUsingEFC() ) { 
     96        debugError( "Could not discover using EFC\n" ); 
     97        return false; 
     98    } 
     99 
     100    // discover AVC-wise 
     101    if ( !GenericAVC::AvDevice::discover() ) { 
     102        debugError( "Could not discover GenericAVC::AvDevice\n" ); 
     103        return false; 
     104    } 
     105 
     106    return true; 
     107
     108 
     109bool 
     110Device::discoverUsingEFC() 
     111
     112    m_efc_discovery_done = false; 
     113 
     114    if (!doEfcOverAVC(m_HwInfo)) { 
     115        debugError("Could not read hardware capabilities\n"); 
     116        return false; 
     117    } 
     118 
     119    // save the EFC version, since some stuff 
     120    // depends on this 
     121    m_efc_version = m_HwInfo.m_header.version; 
     122 
     123    if (!updatePolledValues()) { 
     124        debugError("Could not update polled values\n"); 
     125        return false; 
     126    } 
     127 
     128    m_efc_discovery_done = true; 
     129    return true; 
     130
     131 
     132FFADODevice * 
     133Device::createDevice( Ieee1394Service& ieee1394Service, 
     134                      std::auto_ptr<ConfigRom>( configRom )) 
     135
     136    unsigned int vendorId = configRom->getNodeVendorId(); 
     137    unsigned int modelId = configRom->getModelId(); 
     138 
     139    switch(vendorId) { 
     140        case FW_VENDORID_ECHO: return new ECHO::AudioFire(ieee1394Service, configRom ); 
     141        default: return new Device(ieee1394Service, configRom ); 
     142    } 
     143
     144 
     145bool  
     146Device::doEfcOverAVC(EfcCmd &c) { 
    57147    EfcOverAVCCmd cmd( get1394Service() ); 
    58148    cmd.setCommandType( AVC::AVCCommand::eCT_Control ); 
     
    60150    cmd.setSubunitType( AVC::eST_Unit  ); 
    61151    cmd.setSubunitId( 0xff ); 
    62      
     152 
    63153    cmd.setVerbose( getDebugLevel() ); 
    64     cmd.setVerbose( DEBUG_LEVEL_VERY_VERBOSE ); 
    65  
    66     EfcHardwareInfoCmd *efccmd=new EfcHardwareInfoCmd(); 
    67     if (!efccmd) { 
    68         debugError("could not allocate efc cmd\n"); 
    69         return; 
    70     } 
    71     cmd.m_cmd = efccmd; 
    72  
    73     if ( !cmd.fire() ) { 
     154//     cmd.setVerbose( DEBUG_LEVEL_VERY_VERBOSE ); 
     155 
     156    cmd.m_cmd = &c; 
     157 
     158//     c.showEfcCmd(); 
     159 
     160    if ( !cmd.fire()) { 
    74161        debugError( "EfcOverAVCCmd command failed\n" ); 
    75     } 
    76  
    77     efccmd->showEfcCmd(); 
    78     delete efccmd; 
    79      
    80     // test the next command 
    81     cmd.setCommandType( AVC::AVCCommand::eCT_Control ); 
    82      
    83     EfcPolledValuesCmd *efccmd2=new EfcPolledValuesCmd(); 
    84     if (!efccmd2) { 
    85         debugError("could not allocate efc cmd 2\n"); 
    86         return; 
    87     } 
    88     cmd.m_cmd = efccmd2; 
    89  
    90     if ( !cmd.fire() ) { 
    91         debugError( "EfcOverAVCCmd command failed\n" ); 
    92     } 
    93  
    94     efccmd2->showEfcCmd(); 
    95     delete efccmd2; 
    96      
    97 
    98  
    99  
    100 bool 
    101 Device::probe( ConfigRom& configRom ) 
    102 
    103     unsigned int vendorId = configRom.getNodeVendorId(); 
    104     unsigned int modelId = configRom.getModelId(); 
    105  
    106     GenericAVC::VendorModel vendorModel( SHAREDIR "/ffado_driver_fireworks.txt" ); 
    107     if ( vendorModel.parse() ) { 
    108         vendorModel.printTable(); 
    109         return vendorModel.isPresent( vendorId, modelId ); 
    110     } 
    111  
    112     return false; 
    113 
    114  
    115 bool 
    116 Device::discover() 
    117 
    118     unsigned int vendorId = m_pConfigRom->getNodeVendorId(); 
    119     unsigned int modelId = m_pConfigRom->getModelId(); 
    120  
    121     GenericAVC::VendorModel vendorModel( SHAREDIR "/ffado_driver_fireworks.txt" ); 
    122     if ( vendorModel.parse() ) { 
    123         m_model = vendorModel.find( vendorId, modelId ); 
    124     } 
    125  
    126     if (!GenericAVC::VendorModel::isValid(m_model)) { 
    127         return false; 
    128     } 
    129     debugOutput( DEBUG_LEVEL_VERBOSE, "found %s %s\n", 
    130             m_model.vendor_name.c_str(), m_model.model_name.c_str()); 
    131  
    132     if ( !GenericAVC::AvDevice::discover() ) { 
    133         debugError( "Could not discover GenericAVC::AvDevice\n" ); 
     162        c.showEfcCmd(); 
     163        return false; 
     164    } 
     165//     c.showEfcCmd(); 
     166 
     167    if (   c.m_header.retval != EfcCmd::eERV_Ok 
     168        && c.m_header.retval != EfcCmd::eERV_FlashBusy) { 
     169        debugError( "EFC command failed\n" ); 
     170        c.showEfcCmd(); 
    134171        return false; 
    135172    } 
     
    138175} 
    139176 
    140 FFADODevice * 
    141 Device::createDevice( Ieee1394Service& ieee1394Service, 
    142                       std::auto_ptr<ConfigRom>( configRom )) 
    143 
    144     unsigned int vendorId = configRom->getNodeVendorId(); 
    145  
    146 //     return NULL; 
    147  
    148     unsigned int modelId = configRom->getModelId(); 
    149  
    150     switch(vendorId) { 
    151         case FW_VENDORID_ECHO: return new ECHO::AudioFire(ieee1394Service, configRom ); 
    152         default: return new Device(ieee1394Service, configRom ); 
    153     } 
    154 
    155  
     177bool 
     178Device::updatePolledValues() { 
     179    bool retval; 
     180 
     181    pthread_mutex_lock( &m_polled_mutex ); 
     182    retval = doEfcOverAVC(m_Polled); 
     183    pthread_mutex_unlock( &m_polled_mutex ); 
     184 
     185    return retval; 
     186
     187 
     188FFADODevice::ClockSourceVector 
     189Device::getSupportedClockSources() { 
     190    FFADODevice::ClockSourceVector r; 
     191 
     192    if (!m_efc_discovery_done) { 
     193        debugError("EFC discovery not done yet!\n"); 
     194        return r; 
     195    } 
     196 
     197    uint32_t active_clock=getClock(); 
     198 
     199    if(EFC_CMD_HW_CHECK_FLAG(m_HwInfo.m_supported_clocks, EFC_CMD_HW_CLOCK_INTERNAL)) { 
     200        debugOutput(DEBUG_LEVEL_VERBOSE, "Internal clock supported\n"); 
     201        ClockSource s=clockIdToClockSource(EFC_CMD_HW_CLOCK_INTERNAL); 
     202        s.active=(active_clock == EFC_CMD_HW_CLOCK_INTERNAL); 
     203        if (s.type != eCT_Invalid) r.push_back(s); 
     204    } 
     205    if(EFC_CMD_HW_CHECK_FLAG(m_HwInfo.m_supported_clocks, EFC_CMD_HW_CLOCK_SYTMATCH)) { 
     206        debugOutput(DEBUG_LEVEL_VERBOSE, "Syt Match clock supported\n"); 
     207        ClockSource s=clockIdToClockSource(EFC_CMD_HW_CLOCK_SYTMATCH); 
     208        s.active=(active_clock == EFC_CMD_HW_CLOCK_SYTMATCH); 
     209        if (s.type != eCT_Invalid) r.push_back(s); 
     210    } 
     211    if(EFC_CMD_HW_CHECK_FLAG(m_HwInfo.m_supported_clocks, EFC_CMD_HW_CLOCK_WORDCLOCK)) { 
     212        debugOutput(DEBUG_LEVEL_VERBOSE, "WordClock supported\n"); 
     213        ClockSource s=clockIdToClockSource(EFC_CMD_HW_CLOCK_WORDCLOCK); 
     214        s.active=(active_clock == EFC_CMD_HW_CLOCK_WORDCLOCK); 
     215        if (s.type != eCT_Invalid) r.push_back(s); 
     216    } 
     217    if(EFC_CMD_HW_CHECK_FLAG(m_HwInfo.m_supported_clocks, EFC_CMD_HW_CLOCK_SPDIF)) { 
     218        debugOutput(DEBUG_LEVEL_VERBOSE, "SPDIF clock supported\n"); 
     219        ClockSource s=clockIdToClockSource(EFC_CMD_HW_CLOCK_SPDIF); 
     220        s.active=(active_clock == EFC_CMD_HW_CLOCK_SPDIF); 
     221        if (s.type != eCT_Invalid) r.push_back(s); 
     222    } 
     223    if(EFC_CMD_HW_CHECK_FLAG(m_HwInfo.m_supported_clocks, EFC_CMD_HW_CLOCK_ADAT_1)) { 
     224        debugOutput(DEBUG_LEVEL_VERBOSE, "ADAT 1 clock supported\n"); 
     225        ClockSource s=clockIdToClockSource(EFC_CMD_HW_CLOCK_ADAT_1); 
     226        s.active=(active_clock == EFC_CMD_HW_CLOCK_ADAT_1); 
     227        if (s.type != eCT_Invalid) r.push_back(s); 
     228    } 
     229    if(EFC_CMD_HW_CHECK_FLAG(m_HwInfo.m_supported_clocks, EFC_CMD_HW_CLOCK_ADAT_2)) { 
     230        debugOutput(DEBUG_LEVEL_VERBOSE, "ADAT 2 clock supported\n"); 
     231        ClockSource s=clockIdToClockSource(EFC_CMD_HW_CLOCK_ADAT_2); 
     232        s.active=(active_clock == EFC_CMD_HW_CLOCK_ADAT_2); 
     233        if (s.type != eCT_Invalid) r.push_back(s); 
     234    } 
     235 
     236    return r; 
     237
     238 
     239bool 
     240Device::isClockValid(uint32_t id) { 
     241    // always valid 
     242    if (id==EFC_CMD_HW_CLOCK_INTERNAL) return true; 
     243 
     244    // the polled values are used to detect 
     245    // whether clocks are valid 
     246    if (!updatePolledValues()) { 
     247        debugError("Could not update polled values\n"); 
     248        return false; 
     249    } 
     250    return EFC_CMD_HW_CHECK_FLAG(m_Polled.m_status,id); 
     251
     252 
     253bool 
     254Device::setActiveClockSource(ClockSource s) { 
     255    bool result; 
     256 
     257    debugOutput(DEBUG_LEVEL_VERBOSE, "setting clock source to id: %d\n",s.id); 
     258 
     259    if(!isClockValid(s.id)) { 
     260        debugError("Clock not valid\n"); 
     261        return false; 
     262    } 
     263 
     264    result=setClock(s.id); 
     265 
     266    // From the ECHO sources: 
     267    // "If this is a 1200F and the sample rate is being set via EFC, then 
     268    // send the "phy reconnect command" so the device will vanish and reappear  
     269    // with a new descriptor." 
     270 
     271//     EfcPhyReconnectCmd rccmd; 
     272//     if(!doEfcOverAVC(rccmd)) { 
     273//         debugError("Phy reconnect failed"); 
     274//     } else { 
     275//         // sleep for one second such that the phy can get reconnected 
     276//         sleep(1); 
     277//     } 
     278 
     279    return result; 
     280
     281 
     282FFADODevice::ClockSource 
     283Device::getActiveClockSource() { 
     284    ClockSource s; 
     285    uint32_t active_clock=getClock(); 
     286    s=clockIdToClockSource(active_clock); 
     287    s.active=true; 
     288    return s; 
     289
     290 
     291FFADODevice::ClockSource 
     292Device::clockIdToClockSource(uint32_t clockid) { 
     293    ClockSource s; 
     294    debugOutput(DEBUG_LEVEL_VERBOSE, "clock id: %lu\n", clockid); 
     295 
     296    // the polled values are used to detect 
     297    // whether clocks are valid 
     298    if (!updatePolledValues()) { 
     299        debugError("Could not update polled values\n"); 
     300        return s; 
     301    } 
     302 
     303    switch (clockid) { 
     304        case EFC_CMD_HW_CLOCK_INTERNAL: 
     305            debugOutput(DEBUG_LEVEL_VERBOSE, "Internal clock\n"); 
     306            s.type=eCT_Internal; 
     307            s.description="Internal sync"; 
     308            break; 
     309 
     310        case EFC_CMD_HW_CLOCK_SYTMATCH: 
     311            debugOutput(DEBUG_LEVEL_VERBOSE, "Syt Match\n"); 
     312            s.type=eCT_SytMatch; 
     313            s.description="SYT Match"; 
     314            break; 
     315 
     316        case EFC_CMD_HW_CLOCK_WORDCLOCK: 
     317            debugOutput(DEBUG_LEVEL_VERBOSE, "WordClock\n"); 
     318            s.type=eCT_WordClock; 
     319            s.description="Word Clock"; 
     320            break; 
     321 
     322        case EFC_CMD_HW_CLOCK_SPDIF: 
     323            debugOutput(DEBUG_LEVEL_VERBOSE, "SPDIF clock\n"); 
     324            s.type=eCT_SPDIF; 
     325            s.description="SPDIF"; 
     326            break; 
     327 
     328        case EFC_CMD_HW_CLOCK_ADAT_1: 
     329            debugOutput(DEBUG_LEVEL_VERBOSE, "ADAT 1 clock\n"); 
     330            s.type=eCT_ADAT; 
     331            s.description="ADAT 1"; 
     332            break; 
     333 
     334        case EFC_CMD_HW_CLOCK_ADAT_2: 
     335            debugOutput(DEBUG_LEVEL_VERBOSE, "ADAT 2 clock\n"); 
     336            s.type=eCT_ADAT; 
     337            s.description="ADAT 2"; 
     338            break; 
     339 
     340        default: 
     341            debugError("Invalid clock id: %d\n",clockid); 
     342            return s; // return an invalid ClockSource 
     343    } 
     344 
     345    s.id=clockid; 
     346    s.valid=isClockValid(clockid); 
     347 
     348    return s; 
     349
     350 
     351uint32_t 
     352Device::getClock() { 
     353    EfcGetClockCmd gccmd; 
     354    if (!doEfcOverAVC(gccmd)) { 
     355        debugError("Could not get clock info\n"); 
     356        return EFC_CMD_HW_CLOCK_UNSPECIFIED; 
     357    } 
     358    debugOutput(DEBUG_LEVEL_VERBOSE, "Active clock: 0x%08lX\n",gccmd.m_clock); 
     359    gccmd.showEfcCmd(); 
     360 
     361    return gccmd.m_clock; 
     362
     363 
     364bool 
     365Device::setClock(uint32_t id) { 
     366    EfcGetClockCmd gccmd; 
     367    if (!doEfcOverAVC(gccmd)) { 
     368        debugError("Could not get clock info\n"); 
     369        return false; 
     370    } 
     371    debugOutput(DEBUG_LEVEL_VERBOSE, "Set clock: 0x%08lX\n", id); 
     372 
     373    EfcSetClockCmd sccmd; 
     374    sccmd.m_clock=id; 
     375    sccmd.m_samplerate=gccmd.m_samplerate; 
     376    sccmd.m_index=0; 
     377    if (!doEfcOverAVC(sccmd)) { 
     378        debugError("Could not set clock info\n"); 
     379        return false; 
     380    } 
     381    return true; 
     382
    156383 
    157384} // FireWorks 
  • trunk/libffado/src/fireworks/fireworks_device.h

    r589 r639  
    3030#include "genericavc/avc_avdevice.h" 
    3131 
     32#include "efc/efc_cmd.h" 
     33#include "efc/efc_cmds_hardware.h" 
     34 
     35#include <pthread.h> 
     36 
    3237class ConfigRom; 
    3338class Ieee1394Service; 
     
    4752 
    4853    virtual void showDevice(); 
     54     
     55    virtual ClockSourceVector getSupportedClockSources(); 
     56    virtual bool setActiveClockSource(ClockSource); 
     57    virtual ClockSource getActiveClockSource(); 
     58 
     59// Echo specific stuff 
     60private: 
     61    bool doEfcOverAVC(EfcCmd& c); 
     62     
     63    bool discoverUsingEFC(); 
     64 
     65    FFADODevice::ClockSource clockIdToClockSource(uint32_t clockflag); 
     66    bool isClockValid(uint32_t id); 
     67    uint32_t getClock(); 
     68    bool setClock(uint32_t); 
     69 
     70    uint32_t            m_efc_version; 
     71 
     72    EfcHardwareInfoCmd  m_HwInfo; 
     73 
     74    bool updatePolledValues(); 
     75    pthread_mutex_t     m_polled_mutex; 
     76    EfcPolledValuesCmd  m_Polled; 
     77 
     78    bool                m_efc_discovery_done; 
    4979 
    5080};