Changeset 639

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:

• trunk/libffado/src/bounce/bounce_avdevice.cpp (modified) (1 diff)
• trunk/libffado/src/bounce/bounce_avdevice.h (modified) (1 diff)
• trunk/libffado/src/devicemanager.cpp (modified) (1 diff)
• trunk/libffado/src/dice/dice_avdevice.cpp (modified) (1 diff)
• trunk/libffado/src/dice/dice_avdevice.h (modified) (1 diff)
• trunk/libffado/src/ffadodevice.cpp (modified) (1 diff)
• trunk/libffado/src/ffadodevice.h (modified) (2 diffs)
• trunk/libffado/src/fireworks/audiofire/audiofire_device.h (modified) (1 diff)
• trunk/libffado/src/fireworks/efc/efc_cmd.h (modified) (2 diffs)
• trunk/libffado/src/fireworks/efc/efc_cmds_hardware.cpp (modified) (3 diffs)
• trunk/libffado/src/fireworks/efc/efc_cmds_hardware.h (modified) (1 diff)
• trunk/libffado/src/fireworks/efc/efc_cmds_hardware_ctrl.cpp (added)
• trunk/libffado/src/fireworks/efc/efc_cmds_hardware_ctrl.h (added)
• trunk/libffado/src/fireworks/fireworks_device.cpp (modified) (5 diffs)
• trunk/libffado/src/fireworks/fireworks_device.h (modified) (2 diffs)
• trunk/libffado/src/genericavc/avc_avdevice.cpp (modified) (1 diff)
• trunk/libffado/src/genericavc/avc_avdevice.h (modified) (2 diffs)
• trunk/libffado/src/metrichalo/mh_avdevice.cpp (modified) (1 diff)
• trunk/libffado/src/metrichalo/mh_avdevice.h (modified) (1 diff)
• trunk/libffado/src/motu/motu_avdevice.cpp (modified) (1 diff)
• trunk/libffado/src/motu/motu_avdevice.h (modified) (1 diff)
• trunk/libffado/src/rme/rme_avdevice.cpp (modified) (1 diff)
• trunk/libffado/src/rme/rme_avdevice.h (modified) (1 diff)
• trunk/libffado/src/SConscript (modified) (1 diff)
• trunk/libffado/tests/test-ffado.cpp (modified) (2 diffs)

trunk/libffado/src/bounce/bounce_avdevice.cpp

@@ -145 +145 @@
-}
-
+FFADODevice::ClockSourceVector
+BounceDevice::getSupportedClockSources() {
+    FFADODevice::ClockSourceVector r;
+    return r;
+}
+
+bool
+BounceDevice::setActiveClockSource(ClockSource s) {
+    return false;
+}
+
+FFADODevice::ClockSource
+BounceDevice::getActiveClockSource() {
+    ClockSource s;
+    return s;
+}
+
-int BounceDevice::getConfigurationId( ) {
-    return 0;

trunk/libffado/src/bounce/bounce_avdevice.h

@@ -81 +81 @@
-    virtual bool setSamplingFrequency( int samplingFrequency );
-    virtual int getSamplingFrequency( );
+    
+    virtual ClockSourceVector getSupportedClockSources();
+    virtual bool setActiveClockSource(ClockSource);
+    virtual ClockSource getActiveClockSource();
-
-    virtual bool prepare();

trunk/libffado/src/devicemanager.cpp

@@ -130 +130 @@
-        debugOutput(DEBUG_LEVEL_NORMAL, "--- Device %2d ---\n", i++);
-        avDevice->showDevice();
+
+        debugOutput(DEBUG_LEVEL_NORMAL, "Clock sync sources:\n");
+        FFADODevice::ClockSourceVector sources=avDevice->getSupportedClockSources();
+        for ( FFADODevice::ClockSourceVector::const_iterator it
+                = sources.begin();
+            it != sources.end();
+            ++it )
+        {
+            FFADODevice::ClockSource c=*it;
+            debugOutput(DEBUG_LEVEL_NORMAL, " Type: %s, Id: %d, Valid: %d, Active: %d, Description: %s\n",
+                FFADODevice::ClockSourceTypeToString(c.type), c.id, c.valid, c.active, c.description.c_str());
+        }
+
-    }
-}

trunk/libffado/src/dice/dice_avdevice.cpp

@@ -280 +280 @@
-}
-
+FFADODevice::ClockSourceVector
+DiceAvDevice::getSupportedClockSources() {
+    FFADODevice::ClockSourceVector r;
+    return r;
+}
+
+bool
+DiceAvDevice::setActiveClockSource(ClockSource s) {
+    return false;
+}
+
+FFADODevice::ClockSource
+DiceAvDevice::getActiveClockSource() {
+    ClockSource s;
+    return s;
+}
+
-void
-DiceAvDevice::showDevice()

trunk/libffado/src/dice/dice_avdevice.h

@@ -71 +71 @@
-    virtual bool setSamplingFrequency( int samplingFrequency );
-    virtual int getSamplingFrequency( );
+
+    virtual ClockSourceVector getSupportedClockSources();
+    virtual bool setActiveClockSource(ClockSource);
+    virtual ClockSource getActiveClockSource();
-
-    virtual int getStreamCount();

trunk/libffado/src/ffadodevice.cpp

@@ -148 +148 @@
-    return true;
-}
+
+const char *
+FFADODevice::ClockSourceTypeToString(enum eClockSourceType t)
+{
+    switch(t) {
+        default:            return "Erratic type      ";
+        case eCT_Invalid:   return "Invalid           ";
+        case eCT_Internal:  return "Internal          ";
+        case eCT_1394Bus:   return "1394 Bus          ";
+        case eCT_SytMatch:  return "Compound Syt Match";
+        case eCT_SytStream: return "Sync Syt Match    ";
+        case eCT_WordClock: return "WordClock         ";
+        case eCT_SPDIF:     return "SPDIF             ";
+        case eCT_ADAT:      return "ADAT              ";
+        case eCT_TDIF:      return "TDIF              ";
+        case eCT_AES:       return "AES               ";
+    }
+}

trunk/libffado/src/ffadodevice.h

@@ -31 +31 @@
-#include "libieee1394/vendor_model_ids.h"
-
+#include <vector>
+#include <string>
+
-class ConfigRom;
-class Ieee1394Service;
@@ -149 +152 @@
-
-    /**
+     * @brief clock source types
+     */
+    enum eClockSourceType {
+        eCT_Invalid,   ///> invalid entry (e.g. on error)
+        eCT_Internal,  ///> internal sync (unspecified)
+        eCT_1394Bus,   ///> Sync on the 1394 bus clock (e.g. CSP)
+        eCT_SytMatch,  ///> SYT match on incoming audio stream
+        eCT_SytStream, ///> SYT match on incoming sync stream
+        eCT_WordClock, ///> SYT on WordClock input
+        eCT_SPDIF,     ///> SYT on SPDIF input
+        eCT_ADAT,      ///> SYT on ADAT input
+        eCT_TDIF,      ///> SYT on TDIF input
+        eCT_AES,       ///> SYT on AES input
+    };
+
+    /**
+     * @brief convert the clock source type to a C string
+     * @return a C string describing the clock source type
+     */
+    static const char *ClockSourceTypeToString(enum eClockSourceType);
+
+    /**
+     * @brief Clock source identification struct
+     */
+    struct sClockSource {
+        sClockSource()
+            : type( eCT_Invalid )
+            , id( 0 )
+            , valid( false )
+            , active( false )
+            , description( "" )
+        {}
+        /// indicates the type of the clock source (e.g. eCT_ADAT)
+        enum eClockSourceType type;
+        /// indicated the id of the clock source (e.g. id=1 => clocksource is ADAT_1)
+        unsigned int id;
+        /// is the clock source valid at this moment?
+        bool valid;
+        /// is the clock source active at this moment?
+        bool active;
+        /// description of the clock struct (optional)
+        std::string description;
+    };
+    typedef struct sClockSource ClockSource;
+
+    typedef std::vector< ClockSource > ClockSourceVector;
+    typedef std::vector< ClockSource >::iterator ClockSourceVectorIterator;
+
+    /**
+     * @brief Get the clocksources supported by this device
+     *
+     * This function returns a vector of ClockSource structures that contains
+     * one entry for every clock source supported by the device.
+     *
+     * @returns a vector of ClockSource structures
+     */
+    virtual ClockSourceVector getSupportedClockSources() = 0;
+
+
+    /**
+     * @brief Sets the active clock source of this device
+     *
+     * This function sets the clock source of the device.
+     *
+     * @returns true upon success. false upon failure.
+     */
+    virtual bool setActiveClockSource(ClockSource) = 0;
+
+    /**
+     * @brief Returns the active clock source of this device
+     *
+     * This function returns the active clock source of the device.
+     *
+     * @returns the active ClockSource
+     */
+    virtual ClockSource getActiveClockSource() = 0;
+
+    /**
-     * @brief This is called by the device manager to give the device a unique ID.
-     *

trunk/libffado/src/fireworks/audiofire/audiofire_device.h

@@ -33 +33 @@
-
-class AudioFire : public FireWorks::Device {
+
-public:
-    AudioFire( Ieee1394Service& ieee1394Service,

trunk/libffado/src/fireworks/efc/efc_cmd.h

@@ -45 +45 @@
-#define EFC_CAT_COUNT                   10
-
+// Commands for the EFC_CAT_HARDWARE_INFO category
+#define EFC_CMD_HW_HWINFO_GET_CAPS      0
+#define EFC_CMD_HW_GET_POLLED           1
+#define EFC_CMD_HW_SET_EFR_ADDRESS      2
+#define EFC_CMD_HW_READ_SESSION_BLOCK   3
+#define EFC_CMD_HW_GET_DEBUG_INFO       4
+#define EFC_CMD_HW_SET_DEBUG_TRACKING   5
+#define EFC_CMD_HW_COUNT                6
+
+// Commands for the EFC_CAT_HARDWARE_CONTROL category
+#define EFC_CMD_HWCTRL_SET_CLOCK        0
+#define EFC_CMD_HWCTRL_GET_CLOCK        1
+#define EFC_CMD_HWCTRL_BSX_HANDSHAKE    2
+#define EFC_CMD_HWCTRL_CHANGE_FLAGS     3
+#define EFC_CMD_HWCTRL_GET_FLAGS        4
+#define EFC_CMD_HWCTRL_IDENTIFY         5
+#define EFC_CMD_HWCTRL_RECONNECT_PHY    6
+
-// size of the header
-#define EFC_HEADER_LENGTH_QUADLETS      ((sizeof(uint32_t) + sizeof(struct EfcCmd::efc_header))/4)
@@ -53 +71 @@
-      *(__value__)=ntohl(*(__value__)); } \
-
+
+// specifiers for the flags field
+#define EFC_CMD_HW_DYNADDR_SUPPORTED                1
+#define EFC_CMD_HW_MIRRORING_SUPPORTED              2
+#define EFC_CMD_HW_SPDIF_COAX_SUPPORTED             3
+#define EFC_CMD_HW_SPDIF_AESEBUXLR_SUPPORTED        4
+#define EFC_CMD_HW_HAS_DSP                          5
+#define EFC_CMD_HW_HAS_FPGA                         6
+#define EFC_CMD_HW_HAS_PHANTOM                      7
+
+#define EFC_CMD_HW_CHECK_FLAG(__val__,__flag__) \
+    (((__val__) & (1<<(__flag__))) != 0)
+#define EFC_CMD_HW_TO_FLAG(__val__) \
+    (1<<(__val__))
+
+// Clock sources
+#define EFC_CMD_HW_CLOCK_INTERNAL                   0
+#define EFC_CMD_HW_CLOCK_SYTMATCH                   1
+#define EFC_CMD_HW_CLOCK_WORDCLOCK                  2
+#define EFC_CMD_HW_CLOCK_SPDIF                      3
+#define EFC_CMD_HW_CLOCK_ADAT_1                     4
+#define EFC_CMD_HW_CLOCK_ADAT_2                     5
+#define EFC_CMD_HW_CLOCK_COUNT                      6
+
+#define EFC_CMD_HW_CLOCK_UNSPECIFIED       0xFFFFFFFF
+
+// MIDI flags
+#define EFC_CMD_HW_MIDI_IN_1                        8
+#define EFC_CMD_HW_MIDI_OUT_1                       9
+#define EFC_CMD_HW_MIDI_IN_2                       10
+#define EFC_CMD_HW_MIDI_OUT_2                      11
+
+// Channel types
+#define EFC_CMD_HW_CHANNEL_TYPE_ANALOG              0
+#define EFC_CMD_HW_CHANNEL_TYPE_SPDIF               1
+#define EFC_CMD_HW_CHANNEL_TYPE_ADAT                2
+#define EFC_CMD_HW_CHANNEL_TYPE_SPDIF_OR_ADAT       3
+#define EFC_CMD_HW_CHANNEL_TYPE_ANALOG_MIRRORING    4
+#define EFC_CMD_HW_CHANNEL_TYPE_HEADPHONES          5
+#define EFC_CMD_HW_CHANNEL_TYPE_I2S                 6
-
-namespace FireWorks {

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

@@ -33 +33 @@
-EfcHardwareInfoCmd::EfcHardwareInfoCmd()
-: EfcCmd(EFC_CAT_HARDWARE_INFO, EFC_CMD_HW_HWINFO_GET_CAPS)
+, m_nb_out_groups( 0 )
+, m_nb_in_groups( 0 )
-{}
-
@@ -169 +171 @@
-EfcPolledValuesCmd::EfcPolledValuesCmd()
-: EfcCmd(EFC_CAT_HARDWARE_INFO, EFC_CMD_HW_GET_POLLED)
+, m_nb_output_meters ( 0 )
+, m_nb_input_meters ( 0 )
-{}
-
@@ -195 +199 @@
-    
-    EFC_DESERIALIZE_AND_SWAP(de, &m_detect_spdif, result);
-spdif, result);    
+adat, result);
-    EFC_DESERIALIZE_AND_SWAP(de, &m_reserved3, result);
-    EFC_DESERIALIZE_AND_SWAP(de, &m_reserved4, result);
-
-    EFC_DESERIALIZE_AND_SWAP(de, &m_nb_output_meters, result);
-    
+
-    EFC_DESERIALIZE_AND_SWAP(de, &m_reserved5, result);
-    EFC_DESERIALIZE_AND_SWAP(de, &m_reserved6, result);

trunk/libffado/src/fireworks/efc/efc_cmds_hardware.h

@@ -32 +32 @@
-#define HWINFO_MAX_CAPS_GROUPS      8
-#define POLLED_MAX_NB_METERS        100
-
-// Commands for the EFC_CAT_HARDWARE_INFO category
-#define EFC_CMD_HW_HWINFO_GET_CAPS      0
-#define EFC_CMD_HW_GET_POLLED           1
-#define EFC_CMD_HW_SET_EFR_ADDRESS      2
-#define EFC_CMD_HW_READ_SESSION_BLOCK   3
-#define EFC_CMD_HW_GET_DEBUG_INFO       4
-#define EFC_CMD_HW_SET_DEBUG_TRACKING   5
-#define EFC_CMD_HW_COUNT                6
-
-
-
-class EfcHardwareInfoCmd : public EfcCmd

trunk/libffado/src/fireworks/fireworks_device.cpp

@@ -26 +26 @@
-#include "efc/efc_cmd.h"
-#include "efc/efc_cmds_hardware.h"
+#include "efc/efc_cmds_hardware_ctrl.h"
-
-#include "audiofire/audiofire_device.h"
@@ -40 +41 @@
-                            std::auto_ptr<ConfigRom>( configRom ))
-    : GenericAVC::AvDevice( ieee1394Service, configRom)
+    , m_efc_discovery_done ( false )
-{
-    debugOutput( DEBUG_LEVEL_VERBOSE, "Created FireWorks::Device (NodeID %d)\n",
-                 getConfigRom().getNodeId() );
+    pthread_mutex_init( &m_polled_mutex, 0 );
-}
-
@@ -53 +56 @@
-{
-    debugOutput(DEBUG_LEVEL_VERBOSE, "This is a FireWorks::Device\n");
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    EfcOverAVCCmd cmd( get1394Service() );
-    cmd.setCommandType( AVC::AVCCommand::eCT_Control );
@@ -60 +150 @@
-    cmd.setSubunitType( AVC::eST_Unit  );
-    cmd.setSubunitId( 0xff );
-
+
-    cmd.setVerbose( getDebugLevel() );
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
-        debugError( "EfcOverAVCCmd command failed\n" );
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-        return false;
-    }
@@ -138 +175 @@
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-} // FireWorks

trunk/libffado/src/fireworks/fireworks_device.h

@@ -30 +30 @@
-#include "genericavc/avc_avdevice.h"
-
+#include "efc/efc_cmd.h"
+#include "efc/efc_cmds_hardware.h"
+
+#include <pthread.h>
+
-class ConfigRom;
-class Ieee1394Service;
@@ -47 +52 @@
-
-    virtual void showDevice();
+    
+    virtual ClockSourceVector getSupportedClockSources();
+    virtual bool setActiveClockSource(ClockSource);
+    virtual ClockSource getActiveClockSource();
+
+// Echo specific stuff
+private:
+    bool doEfcOverAVC(EfcCmd& c);
+    
+    bool discoverUsingEFC();
+
+    FFADODevice::ClockSource clockIdToClockSource(uint32_t clockflag);
+    bool isClockValid(uint32_t id);
+    uint32_t getClock();
+    bool setClock(uint32_t);
+
+    uint32_t            m_efc_version;
+
+    EfcHardwareInfoCmd  m_HwInfo;
+
+    bool updatePolledValues();
+    pthread_mutex_t     m_polled_mutex;
+    EfcPolledValuesCmd  m_Polled;
+
+    bool                m_efc_discovery_done;
-
-};

trunk/libffado/src/genericavc/avc_avdevice.cpp

@@ -210 +210 @@
-}
-
+FFADODevice::ClockSourceVector
+AvDevice::getSupportedClockSources() {
+    FFADODevice::ClockSourceVector r;
+
+    PlugVector syncMSUInputPlugs = m_pPlugManager->getPlugsByType(
+        eST_Music,
+        0,
+        0xff,
+        0xff,
+        Plug::eAPA_SubunitPlug,
+        Plug::eAPD_Input,
+        Plug::eAPT_Sync );
+    if ( !syncMSUInputPlugs.size() ) {
+        debugWarning( "No sync input plug for MSU subunit found\n" );
+        return r;
+    }
+
+    for ( SyncInfoVector::const_iterator it
+              = getSyncInfos().begin();
+          it != getSyncInfos().end();
+          ++it )
+    {
+        const SyncInfo si=*it;
+
+        // check if the destination is a MSU input plug
+        bool found=false;
+        for ( PlugVector::const_iterator it2 = syncMSUInputPlugs.begin();
+            it2 != syncMSUInputPlugs.end();
+            ++it2 )
+        {
+            AVC::Plug* msuPlug = *it2;
+            found |= (msuPlug == si.m_destination);
+        }
+
+        if (found) {
+            ClockSource s=syncInfoToClockSource(*it);
+            r.push_back(s);
+        }
+    }
+
+    return r;
+}
+
+bool
+AvDevice::setActiveClockSource(ClockSource s) {
+    Plug *src=m_pPlugManager->getPlug( s.id );
+    if (!src) {
+        debugError("Could not find plug with id %d\n", s.id);
+        return false;
+    }
+
+    for ( SyncInfoVector::const_iterator it
+              = getSyncInfos().begin();
+          it != getSyncInfos().end();
+          ++it )
+    {
+        const SyncInfo si=*it;
+
+        if (si.m_source==src) {
+            return setActiveSync(si);
+        }
+    }
+
+    return false;
+}
+
+FFADODevice::ClockSource
+AvDevice::getActiveClockSource() {
+    const SyncInfo* si=getActiveSyncInfo();
+    if ( !si ) {
+        debugError( "Could not retrieve active sync information\n" );
+        ClockSource s;
+        s.type=eCT_Invalid;
+        return s;
+    }
+    debugOutput(DEBUG_LEVEL_VERBOSE, "Active Sync mode:  %s\n", si->m_description.c_str() );
+
+    return syncInfoToClockSource(*si);
+}
+
+FFADODevice::ClockSource
+AvDevice::syncInfoToClockSource(const SyncInfo& si) {
+    ClockSource s;
+
+    // the description is easy
+    // it can be that we overwrite it later
+    s.description=si.m_description;
+
+    // FIXME: always valid at the moment
+    s.valid=true;
+
+    assert(si.m_source);
+    s.id=si.m_source->getGlobalId();
+
+    // now figure out what type this is
+    switch(si.m_source->getPlugType()) {
+        case Plug::eAPT_IsoStream:
+            s.type=eCT_SytMatch;
+            break;
+        case Plug::eAPT_Sync:
+            if(si.m_source->getPlugAddressType() == Plug::eAPA_PCR) {
+                s.type=eCT_SytStream; // this is logical
+            } else if(si.m_source->getPlugAddressType() == Plug::eAPA_SubunitPlug) {
+                s.type=eCT_Internal; // this assumes some stuff
+            } else if(si.m_source->getPlugAddressType() == Plug::eAPA_ExternalPlug) {
+                std::string plugname=si.m_source->getName();
+                s.description=plugname;
+                // this is basically due to Focusrites interpretation
+                if(plugname.find( "SPDIF", 0 ) != string::npos) {
+                    s.type=eCT_SPDIF; // this assumes the name will tell us
+                } else {
+                    s.type=eCT_WordClock; // this assumes a whole lot more
+                }
+            } else {
+                s.type=eCT_Invalid;
+            }
+            break;
+        case Plug::eAPT_Digital:
+            if(si.m_source->getPlugAddressType() == Plug::eAPA_ExternalPlug) {
+                std::string plugname=si.m_source->getName();
+                s.description=plugname;
+                // this is basically due to Focusrites interpretation
+                if(plugname.find( "ADAT", 0 ) != string::npos) {
+                    s.type=eCT_ADAT; // this assumes the name will tell us
+                } else if(plugname.find( "SPDIF", 0 ) != string::npos) {
+                    s.type=eCT_SPDIF; // this assumes the name will tell us
+                } else {
+                    s.type=eCT_WordClock; // this assumes a whole lot more
+                }
+            } else {
+                s.type=eCT_Invalid;
+            }
+            break;
+        default:
+            s.type=eCT_Invalid; break;
+    }
+
+    // is it active?
+    const SyncInfo* active=getActiveSyncInfo();
+    if (active) {
+        if ((active->m_source == si.m_source)
+           && (active->m_destination == si.m_destination))
+           s.active=true;
+        else s.active=false;
+    } else s.active=false;
+
+    return s;
+}
+
-bool
-AvDevice::lock() {

trunk/libffado/src/genericavc/avc_avdevice.h

@@ -65 +65 @@
-    virtual int getSamplingFrequency( );
-
+    virtual ClockSourceVector getSupportedClockSources();
+    virtual bool setActiveClockSource(ClockSource);
+    virtual ClockSource getActiveClockSource();
+
-    virtual int getStreamCount();
-    virtual Streaming::StreamProcessor *getStreamProcessorByIndex(int i);
@@ -96 +100 @@
-
-    DECLARE_DEBUG_MODULE;
+
+private:
+    ClockSource syncInfoToClockSource(const SyncInfo& si);
-};
-

trunk/libffado/src/metrichalo/mh_avdevice.cpp

@@ -125 +125 @@
-}
-
+FFADODevice::ClockSourceVector
+MHAvDevice::getSupportedClockSources() {
+    FFADODevice::ClockSourceVector r;
+    return r;
+}
+
+bool
+MHAvDevice::setActiveClockSource(ClockSource s) {
+    return false;
+}
+
+FFADODevice::ClockSource
+MHAvDevice::getActiveClockSource() {
+    ClockSource s;
+    return s;
+}
+
+
-int
-MHAvDevice::getConfigurationId( ) {

trunk/libffado/src/metrichalo/mh_avdevice.h

@@ -62 +62 @@
-    virtual int getSamplingFrequency( );
-
+    virtual ClockSourceVector getSupportedClockSources();
+    virtual bool setActiveClockSource(ClockSource);
+    virtual ClockSource getActiveClockSource();
+
-    virtual int getStreamCount();
-    virtual Streaming::StreamProcessor *getStreamProcessorByIndex(int i);

trunk/libffado/src/motu/motu_avdevice.cpp

@@ -304 +304 @@
-}
-
+FFADODevice::ClockSourceVector
+MotuDevice::getSupportedClockSources() {
+    FFADODevice::ClockSourceVector r;
+    return r;
+}
+
+bool
+MotuDevice::setActiveClockSource(ClockSource s) {
+    return false;
+}
+
+FFADODevice::ClockSource
+MotuDevice::getActiveClockSource() {
+    ClockSource s;
+    return s;
+}
+
-bool
-MotuDevice::lock() {

trunk/libffado/src/motu/motu_avdevice.h

@@ -109 +109 @@
-    virtual int getSamplingFrequency( );
-
+    virtual ClockSourceVector getSupportedClockSources();
+    virtual bool setActiveClockSource(ClockSource);
+    virtual ClockSource getActiveClockSource();
+
-    virtual int getStreamCount();
-    virtual Streaming::StreamProcessor *getStreamProcessorByIndex(int i);

trunk/libffado/src/rme/rme_avdevice.cpp

@@ -144 +144 @@
-}
-
+FFADODevice::ClockSourceVector
+RmeDevice::getSupportedClockSources() {
+    FFADODevice::ClockSourceVector r;
+    return r;
+}
+
+bool
+RmeDevice::setActiveClockSource(ClockSource s) {
+    return false;
+}
+
+FFADODevice::ClockSource
+RmeDevice::getActiveClockSource() {
+    ClockSource s;
+    return s;
+}
+
-bool
-RmeDevice::lock() {

trunk/libffado/src/rme/rme_avdevice.h

@@ -64 +64 @@
-    virtual int getSamplingFrequency( );
-
+    virtual ClockSourceVector getSupportedClockSources();
+    virtual bool setActiveClockSource(ClockSource);
+    virtual ClockSource getActiveClockSource();
+
-    virtual int getStreamCount();
-    virtual Streaming::StreamProcessor *getStreamProcessorByIndex(int i);

trunk/libffado/src/SConscript

@@ -108 +108 @@
-        fireworks/efc/efc_cmd.cpp \
-        fireworks/efc/efc_cmds_hardware.cpp \
+        fireworks/efc/efc_cmds_hardware_ctrl.cpp \
-        fireworks/audiofire/audiofire_device.cpp \
-' )

trunk/libffado/tests/test-ffado.cpp

@@ -97 +97 @@
-                    "OPERATION: Discover\n"
-                    "           SetSamplerate samplerate\n"
+                    "           SetClockSource [id]\n"
-                    "           ListOscSpace\n"
-                    "           OscServer\n"
@@ -316 +317 @@
-                }
-            }
+        }
+        delete m_deviceManager;
+        return exitfunction(0);
+    } else if ( strcmp( arguments.args[0], "SetClockSource" ) == 0 ) {
+        char* tail;
+        unsigned int targetid = (unsigned int)strtol( arguments.args[1], &tail, 0 );
+        if ( errno ) {
+            fprintf( stderr,  "Could not parse clock source argument\n" );
+            targetid=0xFFFF;
+        }
+        DeviceManager *m_deviceManager = new DeviceManager();
+        if ( !m_deviceManager ) {
+            fprintf( stderr, "Could not allocate device manager\n" );
+            return exitfunction(-1);
+        }
+        if ( arguments.verbose ) {
+            m_deviceManager->setVerboseLevel(arguments.verbose);
+        }
+        if ( !m_deviceManager->initialize( arguments.port ) ) {
+            fprintf( stderr, "Could not initialize device manager\n" );
+            delete m_deviceManager;
+            return exitfunction(-1);
+        }
+        if ( arguments.verbose ) {
+            m_deviceManager->setVerboseLevel(arguments.verbose);
+        }
+        if ( !m_deviceManager->discover() ) {
+            fprintf( stderr, "Could not discover devices\n" );
+            delete m_deviceManager;
+            return exitfunction(-1);
+        }
+
+        if(arguments.node_id_set) {
+            FFADODevice* avDevice = m_deviceManager->getAvDevice( arguments.node_id );
+            if ( avDevice ) {
+                FFADODevice::ClockSource s;
+            
+                avDevice->setVerboseLevel(arguments.verbose);
+                FFADODevice::ClockSourceVector sources=avDevice->getSupportedClockSources();
+                for ( FFADODevice::ClockSourceVector::const_iterator it
+                        = sources.begin();
+                    it != sources.end();
+                    ++it )
+                {
+                    FFADODevice::ClockSource c=*it;
+                    printf( " Type: %s, Id: %d, Valid: %d, Active: %d, Description: %s\n",
+                        FFADODevice::ClockSourceTypeToString(c.type), c.id, c.valid, c.active, c.description.c_str());
+                    
+                    if (c.id==targetid) {
+                        s=*it;
+                    }
+                }
+                
+                if (s.type != FFADODevice::eCT_Invalid) {
+                    printf("  set clock source to %d\n", s.id);
+                    if ( ! avDevice->setActiveClockSource( s ) ) {
+                        fprintf( stderr, "Could not set clock source\n" );
+                    }
+                } else {
+                    printf("  no clock source with id %d found\n", targetid);
+                }
+            }
+        } else {
+            fprintf( stderr, "please specify a node\n" );
-        }
-        delete m_deviceManager;