Changeset 1239

Show
Ignore:
Timestamp:
06/01/08 04:35:14 (12 years ago)
Author:
ppalmers
Message:
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/libffado/config.h.in

    r1212 r1239  
    8484 
    8585// discovery 
    86 #define ENABLE_DISCOVERY_CACHE               0 
     86#define ENABLE_DISCOVERY_CACHE               1 
    8787 
    8888// watchdog 
  • trunk/libffado/README

    r1230 r1239  
    117117dbus-python (>= 0.82.0),  http://dbus.freedesktop.org/releases/dbus-python/ 
    118118 
    119 The version of PyQt must be chosen to match the version of Qt in use.  For Qt 
    120 4.x use PyQt 4.x, while PyQt 3.x is applicable for all other Qt versions 
     119The version of PyQt must be chosen to match the version of Qt in use.  For 
     120Qt 4.x use PyQt 4.x, while PyQt 3.x is applicable for all other Qt versions 
    121121from 1.43. 
    122122 
  • trunk/libffado/SConstruct

    r1233 r1239  
    2525 
    2626FFADO_API_VERSION="8" 
    27 FFADO_VERSION="1.999.27
     27FFADO_VERSION="2.0.900
    2828 
    2929import os 
     
    6868        BoolOption( "ENABLE_METRIC_HALO", "Enable/Disable the Metric Halo part.", False ), 
    6969        BoolOption( "ENABLE_RME", "Enable/Disable the RME part.", False ), 
    70         BoolOption( "ENABLE_BOUNCE", "Enable/Disable the BOUNCE part.", False ), 
     70        #BoolOption( "ENABLE_BOUNCE", "Enable/Disable the BOUNCE part.", False ), 
    7171        BoolOption( "ENABLE_GENERICAVC", """\ 
    7272Enable/Disable the the generic avc part (mainly used by apple). 
     
    335335        env['ENABLE_BOUNCE'] = True 
    336336 
     337# HACK: when the bounce device gets fixed, remove this 
     338env['ENABLE_BOUNCE'] = False 
     339 
    337340if env['ENABLE_BEBOB'] or env['ENABLE_DICE'] or env['ENABLE_BOUNCE'] or env['ENABLE_FIREWORKS']: 
    338341        env['ENABLE_GENERICAVC'] = True 
  • trunk/libffado/src/bebob/bebob_avdevice.cpp

    r1234 r1239  
    8282 
    8383bool 
    84 AvDevice::probe( ConfigRom& configRom ) 
    85 
    86     unsigned int vendorId = configRom.getNodeVendorId(); 
    87     unsigned int modelId = configRom.getModelId(); 
    88  
    89     GenericAVC::VendorModel vendorModel( SHAREDIR "/ffado_driver_bebob.txt" ); 
    90     if ( vendorModel.parse() ) { 
    91         return vendorModel.isPresent( vendorId, modelId ); 
    92     } 
    93  
    94     return false; 
     84AvDevice::probe( ConfigRom& configRom, bool generic ) 
     85
     86    if(generic) { 
     87        return false; 
     88        // try a bebob-specific command to check for the firmware 
     89        ExtendedPlugInfoCmd extPlugInfoCmd( configRom.get1394Service() ); 
     90        UnitPlugAddress unitPlugAddress( UnitPlugAddress::ePT_PCR, 
     91                                         configRom.getNodeId() ); 
     92        extPlugInfoCmd.setPlugAddress( PlugAddress( PlugAddress::ePD_Input, 
     93                                                    PlugAddress::ePAM_Unit, 
     94                                                    unitPlugAddress ) ); 
     95        extPlugInfoCmd.setNodeId( configRom.getNodeId() ); 
     96        extPlugInfoCmd.setCommandType( AVCCommand::eCT_Status ); 
     97        extPlugInfoCmd.setVerbose( configRom.getVerboseLevel() ); 
     98        ExtendedPlugInfoInfoType extendedPlugInfoInfoType( 
     99            ExtendedPlugInfoInfoType::eIT_NoOfChannels ); 
     100        extendedPlugInfoInfoType.initialize(); 
     101        extPlugInfoCmd.setInfoType( extendedPlugInfoInfoType ); 
     102     
     103        if ( !extPlugInfoCmd.fire() ) { 
     104            debugError( "Number of channels command failed\n" ); 
     105            return false; 
     106        } 
     107     
     108        ExtendedPlugInfoInfoType* infoType = extPlugInfoCmd.getInfoType(); 
     109        if ( infoType 
     110            && infoType->m_plugNrOfChns ) 
     111        { 
     112            return true; 
     113        } 
     114        return false; 
     115    } else { 
     116        // check if device is in supported devices list 
     117        unsigned int vendorId = configRom.getNodeVendorId(); 
     118        unsigned int modelId = configRom.getModelId(); 
     119 
     120        GenericAVC::VendorModel vendorModel( SHAREDIR "/ffado_driver_bebob.txt" ); 
     121        if ( vendorModel.parse() ) { 
     122            return vendorModel.isPresent( vendorId, modelId ); 
     123        } 
     124        return false; 
     125    } 
    95126} 
    96127 
     
    158189                     m_model.vendor_name.c_str(), 
    159190                     m_model.model_name.c_str()); 
    160     } else return false; 
     191    } else { 
     192        debugWarning("Using generic BeBoB support for unsupported device '%s %s'\n",  
     193                     getConfigRom().getVendorName().c_str(), getConfigRom().getModelName().c_str()); 
     194    } 
    161195 
    162196    if ( !Unit::discover() ) { 
  • trunk/libffado/src/bebob/bebob_avdevice.h

    r1175 r1239  
    6363    virtual ~AvDevice(); 
    6464 
    65     static bool probe( ConfigRom& configRom ); 
     65    static bool probe( ConfigRom& configRom, bool generic = false ); 
    6666    virtual bool loadFromCache(); 
    6767    virtual bool saveCache(); 
  • trunk/libffado/src/bounce/bounce_avdevice.cpp

    r1135 r1239  
    7070 
    7171bool 
    72 BounceDevice::probe( ConfigRom& configRom
     72BounceDevice::probe( ConfigRom& configRom, bool generic
    7373{ 
     74    if (generic) return false; 
    7475 
    7576    debugOutput( DEBUG_LEVEL_VERBOSE, "probing BounceDevice\n"); 
  • trunk/libffado/src/bounce/bounce_avdevice.h

    r864 r1239  
    7474    virtual ~BounceDevice(); 
    7575 
    76     static bool probe( ConfigRom& configRom ); 
     76    static bool probe( ConfigRom& configRom, bool generic = false ); 
    7777    static FFADODevice * createDevice( Ieee1394Service& ieee1394Service, 
    7878                                        std::auto_ptr<ConfigRom>( configRom )); 
  • trunk/libffado/src/devicemanager.cpp

    r1212 r1239  
    454454                } 
    455455     
    456                 std::auto_ptr<ConfigRom> configRom = 
    457                     std::auto_ptr<ConfigRom>( new ConfigRom( *portService, nodeId ) ); 
     456                ConfigRom *configRom = new ConfigRom( *portService, nodeId ); 
    458457                if ( !configRom->initialize() ) { 
    459458                    // \todo If a PHY on the bus is in power safe mode then 
     
    496495                // supported devices. 
    497496                if(m_deviceStringParser->countDeviceStrings() && 
    498                   !m_deviceStringParser->match(*configRom.get())) { 
     497                  !m_deviceStringParser->match(*configRom)) { 
    499498                    debugOutput(DEBUG_LEVEL_VERBOSE, "Device doesn't match any of the spec strings. skipping...\n"); 
    500499                    continue; 
     
    546545 
    547546                    debugOutput( DEBUG_LEVEL_NORMAL, "discovery of node %d on port %d done...\n", nodeId, portService->getPort() ); 
     547                } else { 
     548                    // we didn't get a device, hence we have to delete the configrom ptr manually 
     549                    delete configRom; 
    548550                } 
    549551            } 
     
    817819 
    818820FFADODevice* 
    819 DeviceManager::getDriverForDevice( std::auto_ptr<ConfigRom>( configRom )
    820                                    int id
     821DeviceManager::getDriverForDeviceDo( ConfigRom *configRom
     822                                   int id, bool generic
    821823{ 
    822824#ifdef ENABLE_BEBOB 
    823825    debugOutput( DEBUG_LEVEL_VERBOSE, "Trying BeBoB...\n" ); 
    824     if ( BeBoB::AvDevice::probe( *configRom.get() ) ) { 
    825         return BeBoB::AvDevice::createDevice( *this, configRom ); 
    826     } 
    827 #endif 
    828  
     826    if ( BeBoB::AvDevice::probe( *configRom, generic ) ) { 
     827        return BeBoB::AvDevice::createDevice( *this, std::auto_ptr<ConfigRom>( configRom ) ); 
     828    } 
     829#endif 
     830 
     831#ifdef ENABLE_FIREWORKS 
     832    debugOutput( DEBUG_LEVEL_VERBOSE, "Trying ECHO Audio FireWorks...\n" ); 
     833    if ( FireWorks::Device::probe( *configRom, generic ) ) { 
     834        return FireWorks::Device::createDevice( *this, std::auto_ptr<ConfigRom>( configRom ) ); 
     835    } 
     836#endif 
     837 
     838// we want to try the non-generic AV/C platforms before trying the generic ones 
    829839#ifdef ENABLE_GENERICAVC 
    830840    debugOutput( DEBUG_LEVEL_VERBOSE, "Trying Generic AV/C...\n" ); 
    831     if ( GenericAVC::AvDevice::probe( *configRom.get() ) ) { 
    832         return GenericAVC::AvDevice::createDevice( *this, configRom ); 
    833     } 
    834 #endif 
    835  
    836 #ifdef ENABLE_FIREWORKS 
    837     debugOutput( DEBUG_LEVEL_VERBOSE, "Trying ECHO Audio FireWorks...\n" ); 
    838     if ( FireWorks::Device::probe( *configRom.get() ) ) { 
    839         return FireWorks::Device::createDevice( *this, configRom ); 
    840     } 
    841 #endif 
    842  
    843 #ifdef ENABLE_BEBOB 
    844     debugOutput( DEBUG_LEVEL_VERBOSE, "Trying M-Audio...\n" ); 
    845     if ( MAudio::AvDevice::probe( *configRom.get() ) ) { 
    846         return MAudio::AvDevice::createDevice( *this, configRom ); 
     841    if ( GenericAVC::AvDevice::probe( *configRom, generic ) ) { 
     842        return GenericAVC::AvDevice::createDevice( *this, std::auto_ptr<ConfigRom>( configRom ) ); 
    847843    } 
    848844#endif 
     
    850846#ifdef ENABLE_MOTU 
    851847    debugOutput( DEBUG_LEVEL_VERBOSE, "Trying Motu...\n" ); 
    852     if ( Motu::MotuDevice::probe( *configRom.get() ) ) { 
    853         return Motu::MotuDevice::createDevice( *this, configRom ); 
     848    if ( Motu::MotuDevice::probe( *configRom, generic ) ) { 
     849        return Motu::MotuDevice::createDevice( *this, std::auto_ptr<ConfigRom>( configRom ) ); 
    854850    } 
    855851#endif 
     
    857853#ifdef ENABLE_DICE 
    858854    debugOutput( DEBUG_LEVEL_VERBOSE, "Trying Dice...\n" ); 
    859     if ( Dice::DiceAvDevice::probe( *configRom.get() ) ) { 
    860         return Dice::DiceAvDevice::createDevice( *this, configRom ); 
     855    if ( Dice::DiceAvDevice::probe( *configRom, generic ) ) { 
     856        return Dice::DiceAvDevice::createDevice( *this, std::auto_ptr<ConfigRom>( configRom ) ); 
    861857    } 
    862858#endif 
     
    864860#ifdef ENABLE_METRIC_HALO 
    865861    debugOutput( DEBUG_LEVEL_VERBOSE, "Trying Metric Halo...\n" ); 
    866     if ( MetricHalo::MHAvDevice::probe( *configRom.get() ) ) { 
    867         return MetricHalo::MHAvDevice::createDevice( *this, configRom ); 
     862    if ( MetricHalo::MHAvDevice::probe( *configRom, generic ) ) { 
     863        return MetricHalo::MHAvDevice::createDevice( *this, std::auto_ptr<ConfigRom>( configRom ) ); 
    868864    } 
    869865#endif 
     
    871867#ifdef ENABLE_RME 
    872868    debugOutput( DEBUG_LEVEL_VERBOSE, "Trying RME...\n" ); 
    873     if ( Rme::RmeDevice::probe( *configRom.get() ) ) { 
    874         return Rme::RmeDevice::createDevice( *this, configRom ); 
     869    if ( Rme::RmeDevice::probe( *configRom, generic ) ) { 
     870        return Rme::RmeDevice::createDevice( *this, std::auto_ptr<ConfigRom>( configRom ) ); 
    875871    } 
    876872#endif 
     
    878874#ifdef ENABLE_BOUNCE 
    879875    debugOutput( DEBUG_LEVEL_VERBOSE, "Trying Bounce...\n" ); 
    880     if ( Bounce::BounceDevice::probe( *configRom.get() ) ) { 
    881         return Bounce::BounceDevice::createDevice( *this, configRom ); 
    882     } 
    883 #endif 
    884  
     876    if ( Bounce::BounceDevice::probe( *configRom, generic ) ) { 
     877        return Bounce::BounceDevice::createDevice( *this, std::auto_ptr<ConfigRom>( configRom ) ); 
     878    } 
     879#endif 
     880 
     881    return NULL; 
     882
     883 
     884FFADODevice* 
     885DeviceManager::getDriverForDevice( ConfigRom *configRom, 
     886                                   int id ) 
     887
     888    debugOutput( DEBUG_LEVEL_VERBOSE, "Probing for supported device...\n" ); 
     889    FFADODevice* dev = getDriverForDeviceDo(configRom, id, false); 
     890    if(dev) { 
     891        debugOutput( DEBUG_LEVEL_VERBOSE, " found supported device...\n" ); 
     892        return dev; 
     893    } 
     894 
     895    debugOutput( DEBUG_LEVEL_VERBOSE, " no supported device found, trying generic support...\n" ); 
     896    dev = getDriverForDeviceDo(configRom, id, true); 
     897    if(dev) { 
     898        debugOutput( DEBUG_LEVEL_VERBOSE, " found generic support for device...\n" ); 
     899        return dev; 
     900    } 
     901    debugOutput( DEBUG_LEVEL_VERBOSE, " device not supported...\n" ); 
    885902    return 0; 
    886903} 
  • trunk/libffado/src/devicemanager.h

    r1163 r1239  
    131131 
    132132protected: 
    133     FFADODevice* getDriverForDevice( std::auto_ptr<ConfigRom>( configRom ), 
     133    FFADODevice* getDriverForDeviceDo( ConfigRom *configRom, 
     134                                       int id, bool generic ); 
     135    FFADODevice* getDriverForDevice( ConfigRom *configRom, 
    134136                                     int id ); 
    135137    FFADODevice* getSlaveDriver( std::auto_ptr<ConfigRom>( configRom ) ); 
  • trunk/libffado/src/dice/dice_avdevice.cpp

    r1234 r1239  
    101101 
    102102bool 
    103 DiceAvDevice::probe( ConfigRom& configRom
     103DiceAvDevice::probe( ConfigRom& configRom, bool generic
    104104{ 
     105    if (generic) return false; 
    105106    unsigned int vendorId = configRom.getNodeVendorId(); 
    106107    unsigned int modelId = configRom.getModelId(); 
  • trunk/libffado/src/dice/dice_avdevice.h

    r1207 r1239  
    6060    ~DiceAvDevice(); 
    6161 
    62     static bool probe( ConfigRom& configRom ); 
     62    static bool probe( ConfigRom& configRom, bool generic = false ); 
    6363    static FFADODevice * createDevice( DeviceManager& d, std::auto_ptr<ConfigRom>( configRom )); 
    6464    virtual bool discover(); 
  • trunk/libffado/src/fireworks/fireworks_device.cpp

    r1158 r1239  
    7575 
    7676bool 
    77 Device::probe( ConfigRom& configRom ) 
    78 
    79     unsigned int vendorId = configRom.getNodeVendorId(); 
    80     unsigned int modelId = configRom.getModelId(); 
    81  
    82     GenericAVC::VendorModel vendorModel( SHAREDIR "/ffado_driver_fireworks.txt" ); 
    83     if ( vendorModel.parse() ) { 
    84         return vendorModel.isPresent( vendorId, modelId ); 
    85     } 
    86     return false; 
     77Device::probe( ConfigRom& configRom, bool generic ) 
     78
     79    if(generic) { 
     80        // try an EFC command 
     81        EfcOverAVCCmd cmd( configRom.get1394Service() ); 
     82        cmd.setCommandType( AVC::AVCCommand::eCT_Control ); 
     83        cmd.setNodeId( configRom.getNodeId() ); 
     84        cmd.setSubunitType( AVC::eST_Unit  ); 
     85        cmd.setSubunitId( 0xff ); 
     86        cmd.setVerbose( configRom.getVerboseLevel() ); 
     87 
     88        EfcHardwareInfoCmd hwInfo; 
     89        hwInfo.setVerboseLevel(configRom.getVerboseLevel()); 
     90        cmd.m_cmd = &hwInfo; 
     91 
     92        if ( !cmd.fire()) { 
     93            return false; 
     94        } 
     95 
     96        if ( cmd.getResponse() != AVC::AVCCommand::eR_Accepted) { 
     97            return false; 
     98        } 
     99        if ( hwInfo.m_header.retval != EfcCmd::eERV_Ok 
     100             && hwInfo.m_header.retval != EfcCmd::eERV_FlashBusy) { 
     101             debugError( "EFC command failed\n" ); 
     102             return false; 
     103        } 
     104        return true; 
     105    } else { 
     106        unsigned int vendorId = configRom.getNodeVendorId(); 
     107        unsigned int modelId = configRom.getModelId(); 
     108     
     109        GenericAVC::VendorModel vendorModel( SHAREDIR "/ffado_driver_fireworks.txt" ); 
     110        if ( vendorModel.parse() ) { 
     111            return vendorModel.isPresent( vendorId, modelId ); 
     112        } 
     113        return false; 
     114    } 
    87115} 
    88116 
     
    99127 
    100128    if (!GenericAVC::VendorModel::isValid(m_model)) { 
    101         return false; 
    102     } 
    103     debugOutput( DEBUG_LEVEL_VERBOSE, "found %s %s\n", 
    104             m_model.vendor_name.c_str(), m_model.model_name.c_str()); 
     129        debugWarning("Using generic ECHO Audio FireWorks support for unsupported device '%s %s'\n", 
     130            getConfigRom().getVendorName().c_str(), getConfigRom().getModelName().c_str()); 
     131    } else { 
     132        debugOutput( DEBUG_LEVEL_VERBOSE, "found %s %s\n", 
     133                m_model.vendor_name.c_str(), m_model.model_name.c_str()); 
     134    } 
    105135 
    106136    // get the info from the EFC 
  • trunk/libffado/src/fireworks/fireworks_device.h

    r1133 r1239  
    4646    virtual ~Device(); 
    4747     
    48     static bool probe( ConfigRom& configRom ); 
     48    static bool probe( ConfigRom& configRom, bool generic = false ); 
    4949    static FFADODevice * createDevice( DeviceManager& d, std::auto_ptr<ConfigRom>( configRom )); 
    5050    virtual bool discover(); 
  • trunk/libffado/src/genericavc/avc_avdevice.cpp

    r1211 r1239  
    3131#include "libavc/general/avc_plug_info.h" 
    3232#include "libavc/general/avc_extended_plug_info.h" 
     33#include "libavc/general/avc_subunit_info.h" 
    3334 
    3435#include "debugmodule/debugmodule.h" 
     
    7677 
    7778bool 
    78 AvDevice::probe( ConfigRom& configRom ) 
    79 
    80     unsigned int vendorId = configRom.getNodeVendorId(); 
    81     unsigned int modelId = configRom.getModelId(); 
    82  
    83     GenericAVC::VendorModel vendorModel( SHAREDIR "/ffado_driver_genericavc.txt" ); 
    84     if ( vendorModel.parse() ) { 
    85         return vendorModel.isPresent( vendorId, modelId ); 
    86     } 
    87  
    88     return false; 
     79AvDevice::probe( ConfigRom& configRom, bool generic ) 
     80
     81    if(generic) { 
     82        // check if we have a music subunit 
     83        SubUnitInfoCmd subUnitInfoCmd( configRom.get1394Service() ); 
     84        subUnitInfoCmd.setCommandType( AVCCommand::eCT_Status ); 
     85        subUnitInfoCmd.m_page = 0; 
     86        subUnitInfoCmd.setNodeId( configRom.getNodeId() ); 
     87        subUnitInfoCmd.setVerbose( configRom.getVerboseLevel() ); 
     88        if ( !subUnitInfoCmd.fire() ) { 
     89            debugError( "Subunit info command failed\n" ); 
     90            return false; 
     91        } 
     92        for ( int i = 0; i < subUnitInfoCmd.getNrOfValidEntries(); ++i ) { 
     93            subunit_type_t subunit_type 
     94                = subUnitInfoCmd.m_table[i].m_subunit_type; 
     95            if (subunit_type == eST_Music) return true; 
     96        } 
     97 
     98        return false; 
     99    } else { 
     100        // check if device is in supported devices list 
     101        unsigned int vendorId = configRom.getNodeVendorId(); 
     102        unsigned int modelId = configRom.getModelId(); 
     103 
     104        GenericAVC::VendorModel vendorModel( SHAREDIR "/ffado_driver_genericavc.txt" ); 
     105        if ( vendorModel.parse() ) { 
     106            return vendorModel.isPresent( vendorId, modelId ); 
     107        } 
     108        return false; 
     109    } 
    89110} 
    90111 
     
    111132 
    112133        if (!GenericAVC::VendorModel::isValid(m_model)) { 
    113             return false; 
    114         } 
    115         debugOutput( DEBUG_LEVEL_VERBOSE, "found %s %s\n", 
    116                 m_model.vendor_name.c_str(), m_model.model_name.c_str()); 
     134            debugWarning("Using generic AV/C support for unsupported device '%s %s'\n", 
     135                        getConfigRom().getVendorName().c_str(), getConfigRom().getModelName().c_str()); 
     136        } else { 
     137            debugOutput( DEBUG_LEVEL_VERBOSE, "found %s %s\n", 
     138                    m_model.vendor_name.c_str(), m_model.model_name.c_str()); 
     139        } 
    117140    } 
    118141 
  • trunk/libffado/src/genericavc/avc_avdevice.h

    r1154 r1239  
    5151    virtual ~AvDevice(); 
    5252     
    53     static bool probe( ConfigRom& configRom ); 
     53    static bool probe( ConfigRom& configRom, bool generic = false ); 
    5454    virtual bool discover(); 
    5555    static FFADODevice * createDevice( DeviceManager& d, std::auto_ptr<ConfigRom>( configRom )); 
  • trunk/libffado/src/libavc/ccm/avc_signal_source.h

    r864 r1239  
    7272{ 
    7373public: 
     74    enum eOutputStatus { 
     75        eOS_Effective = 0, 
     76        eOS_NotEffective = 1, 
     77        eOS_InsufficientResource = 2, 
     78        eOS_Ready = 3, 
     79        eOS_Output = 4, 
     80    }; 
     81public: 
    7482    SignalSourceCmd( Ieee1394Service& ieee1394service ); 
    7583    virtual ~SignalSourceCmd(); 
  • trunk/libffado/src/libavc/general/avc_plug.cpp

    r1160 r1239  
    3838namespace AVC { 
    3939 
    40 int Plug::m_globalIdCounter = 0; 
    41  
    4240IMPL_DEBUG_MODULE( Plug, Plug, DEBUG_LEVEL_NORMAL ); 
    4341IMPL_DEBUG_MODULE( PlugManager, PlugManager, DEBUG_LEVEL_NORMAL ); 
     
    5957    , m_infoPlugType( eAPT_Unknown ) 
    6058    , m_nrOfChannels( 0 ) 
    61     , m_globalId( m_globalIdCounter++
     59    , m_globalId( unit->getPlugManager().requestNewGlobalId()
    6260{ 
    6361    debugOutput( DEBUG_LEVEL_VERBOSE, 
     
    7674} 
    7775 
     76Plug::Plug( Unit* unit, 
     77            Subunit* subunit, 
     78            function_block_type_t functionBlockType, 
     79            function_block_id_t functionBlockId, 
     80            EPlugAddressType plugAddressType, 
     81            EPlugDirection plugDirection, 
     82            plug_id_t plugId, 
     83            int globalId ) 
     84    : m_unit( unit ) 
     85    , m_subunit( subunit ) 
     86    , m_functionBlockType( functionBlockType ) 
     87    , m_functionBlockId( functionBlockId ) 
     88    , m_addressType( plugAddressType ) 
     89    , m_direction( plugDirection ) 
     90    , m_id( plugId ) 
     91    , m_infoPlugType( eAPT_Unknown ) 
     92    , m_nrOfChannels( 0 ) 
     93{ 
     94    if(globalId < 0) { 
     95        m_globalId = unit->getPlugManager().requestNewGlobalId(); 
     96    } else { 
     97        m_globalId = globalId; 
     98    } 
     99    debugOutput( DEBUG_LEVEL_VERBOSE, 
     100                 "nodeId = %d, subunitType = %d, " 
     101                 "subunitId = %d, functionBlockType = %d, " 
     102                 "functionBlockId = %d, addressType = %d, " 
     103                 "direction = %d, id = %d\n", 
     104                 m_unit->getConfigRom().getNodeId(), 
     105                 getSubunitType(), 
     106                 getSubunitId(), 
     107                 m_functionBlockType, 
     108                 m_functionBlockId, 
     109                 m_addressType, 
     110                 m_direction, 
     111                 m_id ); 
     112} 
     113 
    78114Plug::Plug( const Plug& rhs ) 
    79115    : m_unit ( rhs.m_unit ) 
    80116    , m_subunit ( rhs.m_subunit ) 
     117    , m_subunitType ( rhs.m_subunitType ) 
     118    , m_subunitId ( rhs.m_subunitId ) 
    81119    , m_functionBlockType( rhs.m_functionBlockType ) 
    82120    , m_functionBlockId( rhs.m_functionBlockId ) 
     
    89127    , m_clusterInfos( rhs.m_clusterInfos ) 
    90128    , m_formatInfos( rhs.m_formatInfos ) 
     129// FIXME: how about the global id? 
    91130{ 
    92131    if ( getDebugLevel() ) { 
     
    574613       (getPlugAddressType() == eAPA_ExternalPlug)) { 
    575614        if (getPlugDirection() != eAPD_Output) { 
    576             debugOutput(DEBUG_LEVEL_NORMAL, "Signal Source command not valid for non-output unit plugs...\n"); 
     615            debugOutput(DEBUG_LEVEL_VERBOSE, "Signal Source command not valid for non-output unit plugs...\n"); 
    577616            return -1; 
    578617        } 
     
    581620    if(getPlugAddressType() == eAPA_SubunitPlug) { 
    582621        if (getPlugDirection() != eAPD_Input) { 
    583             debugOutput(DEBUG_LEVEL_NORMAL, "Signal Source command not valid for non-input subunit plugs...\n"); 
     622            debugOutput(DEBUG_LEVEL_VERBOSE, "Signal Source command not valid for non-input subunit plugs...\n"); 
    584623            return -1; 
    585624        } 
     
    614653        if(dynamic_cast<SignalUnitAddress *>(src)) { 
    615654            SignalUnitAddress *usrc=dynamic_cast<SignalUnitAddress *>(src); 
    616             if (usrc->m_plugId & 0x80) { 
     655            if(usrc->m_plugId == 0xFE) { 
     656                debugOutput(DEBUG_LEVEL_VERBOSE, "No/Invalid connection...\n"); 
     657                return -1; 
     658            } else if (usrc->m_plugId & 0x80) { 
    617659                p=m_unit->getPlugManager().getPlug( eST_Unit, 0xFF, 
    618660                        0xFF, 0xFF, eAPA_ExternalPlug, eAPD_Input, 
     
    625667        } else if (dynamic_cast<SignalSubunitAddress *>(src)) { 
    626668            SignalSubunitAddress *susrc=dynamic_cast<SignalSubunitAddress *>(src); 
    627             p=m_unit->getPlugManager().getPlug( byteToSubunitType(susrc->m_subunitType), 
    628                     susrc->m_subunitId, 0xFF, 0xFF, eAPA_SubunitPlug, 
    629                     eAPD_Output, susrc->m_plugId); 
     669            if(susrc->m_plugId == 0xFE) { 
     670                debugOutput(DEBUG_LEVEL_VERBOSE, "No/Invalid connection...\n"); 
     671                return -1; 
     672            } else { 
     673                p=m_unit->getPlugManager().getPlug( byteToSubunitType(susrc->m_subunitType), 
     674                        susrc->m_subunitId, 0xFF, 0xFF, eAPA_SubunitPlug, 
     675                        eAPD_Output, susrc->m_plugId); 
     676            } 
    630677        } else return -1; 
    631678 
    632679        if (p==NULL) { 
    633             debugError("reported signal source plug not found\n"); 
     680            debugError("reported signal source plug not found for '%s'\n", 
     681                       getName()); 
    634682            return -1; 
    635683        } 
     
    16311679    result &= serializePlugVector( basePath + "m_outputConnections", ser, m_outputConnections ); 
    16321680    result &= ser.write( basePath + "m_globalId", m_globalId); 
    1633     result &= ser.write( basePath + "m_globalIdCounter", m_globalIdCounter ); 
    16341681 
    16351682    return result; 
     
    16491696    EPlugDirection        direction; 
    16501697    plug_id_t             id; 
     1698    int                   globalId; 
    16511699 
    16521700    if ( !deser.isExisting( basePath + "m_subunitType" ) ) { 
     
    16651713    result &= deser.read( basePath + "m_direction", direction ); 
    16661714    result &= deser.read( basePath + "m_id", id ); 
     1715    result &= deser.read( basePath + "m_globalId", globalId ); 
    16671716 
    16681717    Plug* pPlug = unit.createPlug( &unit, subunit, functionBlockType,  
    1669                                    functionBlockId, addressType, direction, id); 
     1718                                   functionBlockId, addressType, direction,  
     1719                                   id, globalId); 
    16701720    if ( !pPlug ) { 
    16711721        return 0; 
    16721722    } 
     1723 
     1724    // this is needed to allow for the update of the subunit pointer later on 
     1725    // in the deserializeUpdateSubunit. 
     1726    pPlug->m_subunitType = subunitType; 
     1727    pPlug->m_subunitId = subunitId; 
    16731728 
    16741729    result &= deser.read( basePath + "m_infoPlugType", pPlug->m_infoPlugType ); 
     
    16801735    // input and output connections can't be processed here because not all plugs might 
    16811736    // deserialized at this point. so we do that in deserializeUpdate. 
    1682     result &= deser.read( basePath + "m_globalId", pPlug->m_globalId ); 
    1683     result &= deser.read( basePath + "m_globalIdCounter", pPlug->m_globalIdCounter ); 
    16841737 
    16851738    if ( !result ) { 
     
    17761829 
    17771830PlugManager::PlugManager(  ) 
     1831: m_globalIdCounter( 0 ) 
    17781832{ 
    17791833 
     
    17811835 
    17821836PlugManager::PlugManager( const PlugManager& rhs ) 
     1837: m_globalIdCounter( rhs.m_globalIdCounter ) 
    17831838{ 
    17841839    setDebugLevel( rhs.getDebugLevel() ); 
     
    21652220        i++; 
    21662221    } 
     2222    result &= ser.write( basePath + "m_globalIdCounter", m_globalIdCounter ); 
    21672223 
    21682224    return result; 
     
    21792235    if ( !pMgr ) { 
    21802236        return 0; 
     2237    } 
     2238 
     2239    if(!deser.read( basePath + "m_globalIdCounter", pMgr->m_globalIdCounter )) { 
     2240        pMgr->m_globalIdCounter = 0; 
    21812241    } 
    21822242 
  • trunk/libffado/src/libavc/general/avc_plug.h

    r1154 r1239  
    9292          EPlugDirection plugDirection, 
    9393          plug_id_t plugId ); 
     94    Plug( Unit* unit, 
     95          Subunit* subunit, 
     96          function_block_type_t functionBlockType, 
     97          function_block_type_t functionBlockId, 
     98          EPlugAddressType plugAddressType, 
     99          EPlugDirection plugDirection, 
     100          plug_id_t plugId, 
     101          int globalId ); 
    94102    Plug( const Plug& rhs ); 
    95103    virtual ~Plug(); 
     
    294302    PlugVector                  m_outputConnections; 
    295303    int                         m_globalId; 
    296     static int                  m_globalIdCounter; 
    297304 
    298305    DECLARE_DEBUG_MODULE; 
     
    317324    int getPlugCount() 
    318325        { return m_plugs.size(); }; 
     326 
     327    int requestNewGlobalId() 
     328        { return m_globalIdCounter++; }; 
    319329 
    320330    Plug* getPlug( ESubunitType subunitType, 
     
    347357 
    348358private: 
     359    int m_globalIdCounter; 
    349360 
    350361    PlugVector   m_plugs; 
  • trunk/libffado/src/libavc/general/avc_unit.cpp

    r1211 r1239  
    6666                  Plug::EPlugAddressType plugAddressType, 
    6767                  Plug::EPlugDirection plugDirection, 
    68                   plug_id_t plugId ) 
     68                  plug_id_t plugId, 
     69                  int globalId ) 
    6970{ 
    7071 
     
    7576                       plugAddressType, 
    7677                       plugDirection, 
    77                        plugId ); 
     78                       plugId, 
     79                       globalId ); 
    7880    if (p) p->setVerboseLevel(getDebugLevel()); 
    7981    return p; 
     
    787789                } 
    788790            } 
    789             debugOutput( DEBUG_LEVEL_NORMAL, 
    790                          "Active Sync Connection: %s, '%s' -> '%s'\n", 
    791                          m_activeSyncInfo->m_description.c_str(), 
    792                          plug->getName(), 
    793                          msuPlug->getName() ); 
     791            if(m_activeSyncInfo) { 
     792                debugOutput( DEBUG_LEVEL_NORMAL, 
     793                            "Active Sync Connection: %s, '%s' -> '%s'\n", 
     794                            m_activeSyncInfo->m_description.c_str(), 
     795                            plug->getName(), 
     796                            msuPlug->getName() ); 
     797            } 
    794798        } 
    795799    } 
     
    827831bool Unit::setActiveSync(const SyncInfo& syncInfo) 
    828832{ 
    829     bool result = syncInfo.m_source->setConnection( *syncInfo.m_destination ); 
     833    bool result = true; 
     834 
     835    if(!syncInfo.m_source->setConnection( *syncInfo.m_destination )) { 
     836        debugWarning("Could not set sync source connection.\n"); 
     837    } 
     838 
    830839    result &= updateActiveSyncInfo(); 
    831840    return result; 
     
    10221031    result &= deserializePlugVector( basePath + "ExternalPlug", deser, 
    10231032                                     getPlugManager(), m_externalPlugs ); 
    1024     result &= deserializeVector<PlugConnection>( basePath + "PlugConnnection", deser, 
     1033    result &= deserializeVector<PlugConnection>( basePath + "PlugConnection", deser, 
    10251034                                                 *this, m_plugConnections ); 
    10261035    result &= deserializeVector<Subunit>( basePath + "Subunit",  deser, *this, m_subunits ); 
  • trunk/libffado/src/libavc/general/avc_unit.h

    r1159 r1239  
    114114                                   AVC::Plug::EPlugAddressType plugAddressType, 
    115115                                   AVC::Plug::EPlugDirection plugDirection, 
    116                                    AVC::plug_id_t plugId ); 
     116                                   AVC::plug_id_t plugId, 
     117                                   int globalId = -1 ); 
    117118 
    118119protected: 
  • trunk/libffado/src/maudio/maudio_avdevice.cpp

    r1177 r1239  
    5959 
    6060bool 
    61 AvDevice::probe( ConfigRom& configRom
     61AvDevice::probe( ConfigRom& configRom, bool generic
    6262{ 
     63    if (generic) return false; 
     64 
    6365    unsigned int iVendorId = configRom.getNodeVendorId(); 
    6466    unsigned int iModelId = configRom.getModelId(); 
  • trunk/libffado/src/maudio/maudio_avdevice.h

    r1177 r1239  
    5757    virtual ~AvDevice(); 
    5858 
    59     static bool probe( ConfigRom& configRom ); 
     59    static bool probe( ConfigRom& configRom, bool generic = false ); 
    6060    static FFADODevice * createDevice( DeviceManager& d, std::auto_ptr<ConfigRom>( configRom )); 
    6161    virtual bool discover(); 
  • trunk/libffado/src/metrichalo/mh_avdevice.cpp

    r1135 r1239  
    5050}; 
    5151 
    52 MHAvDevice::MHAvDevice( Ieee1394Service& ieee1394Service
     52MHAvDevice::MHAvDevice( DeviceManager& d
    5353                        std::auto_ptr<ConfigRom>( configRom )) 
    54     : FFADODevice( ieee1394Service, configRom ) 
     54    : FFADODevice( d, configRom ) 
    5555    , m_model( NULL ) 
    5656 
     
    6666 
    6767bool 
    68 MHAvDevice::probe( ConfigRom& configRom ) 
    69 
     68MHAvDevice::probe( ConfigRom& configRom, bool generic ) 
     69
     70    if (generic) return false; 
    7071    unsigned int vendorId = configRom.getNodeVendorId(); 
    7172    unsigned int modelId = configRom.getModelId(); 
     
    8788 
    8889FFADODevice * 
    89 MHAvDevice::createDevice( Ieee1394Service& ieee1394Service
     90MHAvDevice::createDevice( DeviceManager& d
    9091                          std::auto_ptr<ConfigRom>( configRom )) 
    9192{ 
    92     return new MHAvDevice(ieee1394Service, configRom ); 
     93    return new MHAvDevice(d, configRom ); 
    9394} 
    9495 
     
    9697MHAvDevice::discover() 
    9798{ 
    98     unsigned int vendorId = m_pConfigRom->getNodeVendorId(); 
    99     unsigned int modelId = m_pConfigRom->getModelId(); 
     99    unsigned int vendorId = getConfigRom().getNodeVendorId(); 
     100    unsigned int modelId = getConfigRom().getModelId(); 
    100101 
    101102    for ( unsigned int i = 0; 
  • trunk/libffado/src/metrichalo/mh_avdevice.h

    r864 r1239  
    4747class MHAvDevice : public FFADODevice { 
    4848public: 
    49     MHAvDevice( Ieee1394Service& ieee1394Service
     49    MHAvDevice( DeviceManager& d
    5050                std::auto_ptr<ConfigRom>( configRom )); 
    5151    virtual ~MHAvDevice(); 
    5252 
    53     static bool probe( ConfigRom& configRom ); 
    54     static FFADODevice * createDevice( Ieee1394Service& ieee1394Service
    55                                         std::auto_ptr<ConfigRom>( configRom )); 
     53    static bool probe( ConfigRom& configRom, bool generic = false ); 
     54    static FFADODevice * createDevice( DeviceManager& d
     55                                       std::auto_ptr<ConfigRom>( configRom )); 
    5656    static int getConfigurationId(); 
    5757    virtual bool discover(); 
  • trunk/libffado/src/motu/motu_avdevice.cpp

    r1234 r1239  
    588588 
    589589bool 
    590 MotuDevice::probe( ConfigRom& configRom ) 
    591 
     590MotuDevice::probe( ConfigRom& configRom, bool generic) 
     591
     592    if(generic) return false; 
     593 
    592594    unsigned int vendorId = configRom.getNodeVendorId(); 
    593595    unsigned int unitVersion = configRom.getUnitVersion(); 
  • trunk/libffado/src/motu/motu_avdevice.h

    r1128 r1239  
    151151    virtual bool destroyMixer(); 
    152152 
    153     static bool probe( ConfigRom& configRom ); 
     153    static bool probe( ConfigRom& configRom, bool generic = false ); 
    154154    static FFADODevice * createDevice( DeviceManager& d, std::auto_ptr<ConfigRom>( configRom )); 
    155155    static int getConfigurationId( ); 
  • trunk/libffado/src/rme/rme_avdevice.cpp

    r1136 r1239  
    6868 
    6969bool 
    70 RmeDevice::probe( ConfigRom& configRom ) 
    71 
     70RmeDevice::probe( ConfigRom& configRom, bool generic ) 
     71
     72    if (generic) return false; 
    7273    unsigned int vendorId = configRom.getNodeVendorId(); 
    7374    unsigned int unitVersion = configRom.getUnitVersion(); 
  • trunk/libffado/src/rme/rme_avdevice.h

    r981 r1239  
    6666    virtual ~RmeDevice(); 
    6767 
    68     static bool probe( ConfigRom& configRom ); 
     68    static bool probe( ConfigRom& configRom, bool generic = false ); 
    6969    static FFADODevice * createDevice( DeviceManager& d, 
    7070                                        std::auto_ptr<ConfigRom>( configRom )); 
  • trunk/libffado/support/dbus/ffado-dbus-server.cpp

    r1211 r1239  
    104104 
    105105    {"verbose",  'v', "level",    0,  "Produce verbose output" }, 
    106     {"cache",    'c', "enable",   0,  "Use AVC model cache (default=enable)" }, 
    107  
     106#if ENABLE_DISCOVERY_CACHE 
     107    {"cache",    'c', "enable",   0,  "Use AVC model cache" }, 
     108#endif 
    108109 
    109110    {"node",     'n',    "id",    0,  "Only expose mixer of a device on a specific node" }, 
  • trunk/libffado/support/mixer/ffadomixer.in

    r1217 r1239  
    6363SupportedDevices=[ 
    6464    [(0x000aac, 0x00000003),'Phase88Control'], 
    65     [(0x000aac, 0x00000004),'PhaseX24Control'], 
    66     [(0x000aac, 0x00000007),'PhaseX24Control'], 
     65    [(0x000aac, 0x00000004),'Phase24Control'], 
     66    [(0x000aac, 0x00000007),'Phase24Control'], 
    6767    [(0x00130e, 0x00000003),'SaffireProMixer'], 
    6868    [(0x00130e, 0x00000006),'SaffireProMixer'], 
  • trunk/libffado/support/mixer/mixer_phase24.py

    r1106 r1239  
    2424from mixer_phase24ui import * 
    2525 
    26 class PhaseX24Control(PhaseX24ControlUI): 
     26class Phase24Control(Phase24ControlUI): 
    2727    def __init__(self,parent = None,name = None,fl = 0): 
    28         PhaseX24ControlUI.__init__(self,parent,name,fl) 
     28        Phase24ControlUI.__init__(self,parent,name,fl) 
    2929        self.init() 
    3030 
     
    5151    # public slot 
    5252    def setVolumeMaster(self,a0): 
     53        if self.isPhaseX24: 
     54            return 
    5355        self.setVolume('master', a0) 
    5456 
     
    6062    # public slot 
    6163    def setFrontLevel(self,a0): 
     64        if self.isPhaseX24: 
     65            return 
    6266        if(a0 == 0): 
    6367            print "setting front level to %d" % (0) 
     
    100104 
    101105            self.VolumeControls={ 
    102                 'master':         ['/Mixer/Feature_1', self.sldMaster],  
    103106                'analogin' :      ['/Mixer/Feature_6', self.sldLineIn], 
    104107                'spdifin' :       ['/Mixer/Feature_7', self.sldSPDIFIn], 
     
    116119 
    117120    def initValues(self): 
     121            self.modelId = self.configrom.getModelId() 
     122            if self.modelId == 0x00000007: 
     123                self.isPhaseX24 = True 
     124            else: 
     125                self.isPhaseX24 = False 
     126 
     127            if self.isPhaseX24: 
     128                self.setCaption("Terratec Phase X24 Control") 
     129                self.cmbFrontLevel.setEnabled(False) 
     130                self.sldMaster.setEnabled(False) 
     131            else: 
     132                self.setCaption("Terratec Phase 24 Control") 
     133 
     134                self.VolumeControls['master'] = ['/Mixer/Feature_1', self.sldMaster] 
     135                self.sldMaster.setEnabled(True) 
     136 
     137                self.cmbFrontLevel.setEnabled(True) 
     138                val=self.hw.getContignuous('/Mixer/Feature_8') 
     139                if val>0: 
     140                    self.cmbFrontLevel.setCurrentItem(1) 
     141                else: 
     142                    self.cmbFrontLevel.setCurrentItem(0) 
     143 
    118144            for name, ctrl in self.VolumeControls.iteritems(): 
    119145                vol = self.hw.getContignuous(ctrl[0]) 
     
    128154            val=self.hw.getContignuous('/Mixer/Feature_2')/-768 
    129155            if val>4: 
    130                 self.cmbFrontLevel.setCurrentItem(4) 
     156                self.cmbLineLevel.setCurrentItem(4) 
    131157            else: 
    132                 self.cmbFrontLevel.setCurrentItem(val) 
    133  
    134             val=self.hw.getContignuous('/Mixer/Feature_8') 
    135             if val>0: 
    136                 self.cmbFrontLevel.setCurrentItem(1) 
    137             else: 
    138                 self.cmbFrontLevel.setCurrentItem(0) 
     158                self.cmbLineLevel.setCurrentItem(val) 
  • trunk/libffado/support/mixer/mixer_phase24.ui

    r1127 r1239  
    11<!DOCTYPE UI><UI version="3.3" stdsetdef="1"> 
    2 <class>PhaseX24ControlUI</class> 
     2<class>Phase24ControlUI</class> 
    33<comment>Copyright (C) 2005-2008 by Pieter Palmers 
    44         
     
    2020<widget class="QWidget"> 
    2121    <property name="name"> 
    22         <cstring>PhaseX24ControlUI</cstring> 
     22        <cstring>Phase24ControlUI</cstring> 
    2323    </property> 
    2424    <property name="geometry"> 
     
    625625        <sender>sldInput12</sender> 
    626626        <signal>valueChanged(int)</signal> 
    627         <receiver>PhaseX24ControlUI</receiver> 
     627        <receiver>Phase24ControlUI</receiver> 
    628628        <slot>setVolume12(int)</slot> 
    629629    </connection> 
     
    631631        <sender>sldInput34</sender> 
    632632        <signal>valueChanged(int)</signal> 
    633         <receiver>PhaseX24ControlUI</receiver> 
     633        <receiver>Phase24ControlUI</receiver> 
    634634        <slot>setVolume34(int)</slot> 
    635635    </connection> 
     
    637637        <sender>sldLineIn</sender> 
    638638        <signal>valueChanged(int)</signal> 
    639         <receiver>PhaseX24ControlUI</receiver> 
     639        <receiver>Phase24ControlUI</receiver> 
    640640        <slot>setVolumeLineIn(int)</slot> 
    641641    </connection> 
     
    643643        <sender>sldSPDIFOut</sender> 
    644644        <signal>valueChanged(int)</signal> 
    645         <receiver>PhaseX24ControlUI</receiver> 
     645        <receiver>Phase24ControlUI</receiver> 
    646646        <slot>setVolumeSPDIFOut(int)</slot> 
    647647    </connection> 
     
    649649        <sender>sldSPDIFIn</sender> 
    650650        <signal>valueChanged(int)</signal> 
    651         <receiver>PhaseX24ControlUI</receiver> 
     651        <receiver>Phase24ControlUI</receiver> 
    652652        <slot>setVolumeSPDIFIn(int)</slot> 
    653653    </connection> 
     
    655655        <sender>sldMaster</sender> 
    656656        <signal>valueChanged(int)</signal> 
    657         <receiver>PhaseX24ControlUI</receiver> 
     657        <receiver>Phase24ControlUI</receiver> 
    658658        <slot>setVolumeMaster(int)</slot> 
    659659    </connection> 
     
    661661        <sender>cmbFrontLevel</sender> 
    662662        <signal>activated(int)</signal> 
    663         <receiver>PhaseX24ControlUI</receiver> 
     663        <receiver>Phase24ControlUI</receiver> 
    664664        <slot>setFrontLevel(int)</slot> 
    665665    </connection> 
     
    667667        <sender>cmbSetSyncSource</sender> 
    668668        <signal>activated(int)</signal> 
    669         <receiver>PhaseX24ControlUI</receiver> 
     669        <receiver>Phase24ControlUI</receiver> 
    670670        <slot>setSyncSource(int)</slot> 
    671671    </connection> 
     
    673673        <sender>cmbOutSourceSPDIF</sender> 
    674674        <signal>activated(int)</signal> 
    675         <receiver>PhaseX24ControlUI</receiver> 
     675        <receiver>Phase24ControlUI</receiver> 
    676676        <slot>setOutSourceSPDIF(int)</slot> 
    677677    </connection> 
     
    679679        <sender>cmbOutSource12</sender> 
    680680        <signal>activated(int)</signal> 
    681         <receiver>PhaseX24ControlUI</receiver> 
     681        <receiver>Phase24ControlUI</receiver> 
    682682        <slot>setOutSource12(int)</slot> 
    683683    </connection> 
     
    685685        <sender>cmbOutSource34</sender> 
    686686        <signal>activated(int)</signal> 
    687         <receiver>PhaseX24ControlUI</receiver> 
     687        <receiver>Phase24ControlUI</receiver> 
    688688        <slot>setOutSource34(int)</slot> 
    689689    </connection> 
     
    691691        <sender>cmbLineLevel</sender> 
    692692        <signal>activated(int)</signal> 
    693         <receiver>PhaseX24ControlUI</receiver> 
     693        <receiver>Phase24ControlUI</receiver> 
    694694        <slot>setLineLevel(int)</slot> 
    695695    </connection> 
  • trunk/libffado/support/mixer/mixer_saffire.py

    r1217 r1239  
    125125        } 
    126126 
     127    def updateMatrixVolume(self,a0): 
     128        SaffireMixerBase.updateMatrixVolume(self,a0) 
     129    def updateLowResVolume(self,a0): 
     130        SaffireMixerBase.updateLowResVolume(self,a0) 
     131    def updateSelector(self,a0): 
     132        SaffireMixerBase.updateSelector(self,a0) 
     133    def triggerButton(self): 
     134        SaffireMixerBase.triggerButton(self) 
     135    def saveText(self): 
     136        SaffireMixerBase.saveText(self) 
     137    def initCombo(self, combo): 
     138        SaffireMixerBase.initCombo(self,combo) 
     139    def selectCombo(self, mode): 
     140        SaffireMixerBase.selectCombo(self,mode) 
     141 
     142    def updateValues(self): 
     143        SaffireMixerBase.updateValues(self) 
  • trunk/libffado/support/mixer/SConscript

    r1225 r1239  
    4747                     ] 
    4848    e['OTHERGUIS'] = ['ffado_regdialog'] 
    49     e['OTHERAPPS'] = ['ffado_regdialog'
     49    e['OTHERAPPS'] = ['ffado_regdialog', 'mixer_saffire_base'
    5050 
    5151    # 
  • trunk/libffado/tests/test-ffado.cpp

    r1184 r1239  
    9090 
    9191    {"verbose",  'v', "level",    0,  "Produce verbose output" }, 
    92     {"cache",    'c', "enable",   0,  "Use AVC model cache (default=enabled)" }, 
    93  
     92#if ENABLE_DISCOVERY_CACHE 
     93    {"cache",    'c', "enable",   0,  "Use AVC model cache" }, 
     94#endif 
    9495 
    9596    {"node",     'n',    "id",    0,  "Node to use" }, 
     
    131132            } 
    132133        } 
    133         break;       
     134        break; 
    134135    case 'p': 
    135136        if (arg) {