Changeset 262

Show
Ignore:
Timestamp:
06/12/06 18:31:27 (16 years ago)
Author:
jwoithe
Message:

Make skeleton MOTU device discovery work. Proof-of-concept MOTU sample rate
control in place.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/libfreebob-2.0/src/configrom.cpp

    r225 r262  
    6161    , m_vendorName( "" ) 
    6262    , m_modelName( "" ) 
     63    , m_unit_specifier_id( 0 ) 
     64    , m_unit_version( 0 ) 
    6365    , m_vendorNameKv( 0 ) 
    6466    , m_modelNameKv( 0 ) 
     
    208210    struct csr1212_keyval *kv; 
    209211    unsigned int last_key_id = 0; 
    210     unsigned int specifier_id = 0; 
    211212 
    212213    debugOutput( DEBUG_LEVEL_VERBOSE, "process unit directory:\n" ); 
     
    233234                             "\tspecifier_id = 0x%08x\n", 
    234235                             kv->value.immediate); 
    235                 specifier_id = kv->value.immediate; 
     236                m_unit_specifier_id = kv->value.immediate; 
    236237                break; 
    237238 
     
    240241                             "\tversion = 0x%08x\n", 
    241242                             kv->value.immediate); 
    242                 if ( specifier_id == 0x0000a02d ) // XXX 
     243                m_unit_version = kv->value.immediate; 
     244                if ( m_unit_specifier_id == 0x0000a02d ) // XXX 
    243245                { 
    244246                    if ( kv->value.immediate == 0x10001 ) { 
     
    366368    return m_vendorId; 
    367369} 
     370 
     371const unsigned int 
     372ConfigRom::getUnitSpecifierId() const 
     373{ 
     374    return m_unit_specifier_id; 
     375} 
     376 
     377const unsigned int 
     378ConfigRom::getUnitVersion() const 
     379{ 
     380    return m_unit_version; 
     381} 
  • branches/libfreebob-2.0/src/configrom.h

    r199 r262  
    4646    const unsigned int getModelId() const; 
    4747    const unsigned int getVendorId() const; 
    48  
     48    const unsigned int getUnitSpecifierId() const; 
     49    const unsigned int getUnitVersion() const; 
     50         
    4951 protected: 
    5052    void processUnitDirectory( struct csr1212_csr*    csr, 
     
    6264    unsigned int     m_vendorId; 
    6365    unsigned int     m_modelId; 
     66    unsigned int     m_unit_specifier_id; 
     67    unsigned int     m_unit_version; 
    6468 
    6569    /* only used during parsing */ 
  • branches/libfreebob-2.0/src/devicemanager.cpp

    r246 r262  
    3535#include <unistd.h> 
    3636 
     37// Unit directory SpecifierID/Version identifying a true Bebob AVC device 
     38#define BEBOB_AVCDEVICE_UNIT_SPECIFIER   0x0000a02d 
     39#define BEBOB_AVCDEVICE_UNIT_VERSION     0x10001 
     40 
    3741using namespace std; 
    3842 
     
    110114        } 
    111115 
    112         if ( !configRom.isAvcDevice() ) { 
    113             continue; 
    114         } 
    115  
    116116        for ( ProbeFunctionVector::iterator it = m_probeList.begin(); 
    117117              it != m_probeList.end(); 
     
    119119        { 
    120120            ProbeFunction func = *it; 
    121             IAvDevice* avDevice = func(*m_1394Service, nodeId, verboseLevel); 
     121            IAvDevice* avDevice = func(*m_1394Service, configRom, nodeId, verboseLevel); 
    122122            if ( avDevice ) { 
    123123                m_avDevices.push_back( avDevice ); 
     
    139139 
    140140IAvDevice* 
    141 DeviceManager::probeBeBoB(Ieee1394Service& service, int id, int level) 
    142 
    143     IAvDevice* avDevice = new BeBoB_Light::AvDevice( service, id, level ); 
     141DeviceManager::probeBeBoB(Ieee1394Service& service, ConfigRom& configRom, int id, int level) 
     142
     143    IAvDevice* avDevice; 
     144 
     145    // All BeBob devices have predictable unit specifier/version fields 
     146    if (configRom.getUnitSpecifierId() != BEBOB_AVCDEVICE_UNIT_SPECIFIER || 
     147        configRom.getUnitVersion() == BEBOB_AVCDEVICE_UNIT_VERSION) { 
     148        debugOutput( DEBUG_LEVEL_VERBOSE, "Not a BeBoB device...\n" ); 
     149        return NULL; 
     150    } 
     151 
     152    avDevice = new BeBoB_Light::AvDevice( service, id, level ); 
    144153    if ( !avDevice ) { 
    145154        return NULL; 
     
    149158        delete avDevice; 
    150159        debugOutput( DEBUG_LEVEL_VERBOSE, "Not a BeBoB device...\n" ); 
    151        return NULL; 
     160        return NULL; 
    152161    } 
    153162    debugOutput( DEBUG_LEVEL_VERBOSE, "BeBoB device discovered...\n" ); 
     
    156165 
    157166IAvDevice* 
    158 DeviceManager::probeBounce(Ieee1394Service& service, int id, int level) 
    159 
    160     IAvDevice* avDevice = new Bounce::BounceDevice( service, id, level ); 
     167DeviceManager::probeBounce(Ieee1394Service& service, ConfigRom& configRom, int id, int level) 
     168
     169    IAvDevice* avDevice; 
     170 
     171    // All Bounce devices have predictable unit specifier/version fields 
     172    if (configRom.getUnitSpecifierId() != BEBOB_AVCDEVICE_UNIT_SPECIFIER || 
     173        configRom.getUnitVersion() == BEBOB_AVCDEVICE_UNIT_VERSION) { 
     174        debugOutput( DEBUG_LEVEL_VERBOSE, "Not a Bounce device...\n" ); 
     175        return NULL; 
     176    } 
     177 
     178    avDevice = new Bounce::BounceDevice( service, id, level ); 
    161179    if ( !avDevice ) { 
    162180        return NULL; 
     
    165183    if ( !avDevice->discover() ) { 
    166184        debugOutput( DEBUG_LEVEL_VERBOSE, "Not a Bounce device...\n"); 
    167      
    168185        delete avDevice; 
    169186        return NULL; 
     
    175192 
    176193IAvDevice* 
    177 DeviceManager::probeMotu(Ieee1394Service& service, int id, int level) 
     194DeviceManager::probeMotu(Ieee1394Service& service, ConfigRom& configRom, int id, int level) 
    178195{ 
    179196    IAvDevice* avDevice = new Motu::MotuDevice( service, id, level ); 
     
    182199    } 
    183200 
     201    // MOTU's discover() needs to differentiate between different models, 
     202    // so for now keep all probing code in there since it's very intermingled. 
     203    // The code is robust in the event that the device isn't a MOTU, so 
     204    // at this stage there seems no reason to do otherwise. 
    184205    if ( !avDevice->discover() ) { 
     206        debugOutput( DEBUG_LEVEL_VERBOSE, "Not a MOTU device...\n"); 
    185207        delete avDevice; 
    186208        return NULL; 
    187209    } 
     210    debugOutput( DEBUG_LEVEL_VERBOSE, "MOTU device discovered...\n"); 
     211 
    188212    return avDevice; 
    189213} 
  • branches/libfreebob-2.0/src/devicemanager.h

    r221 r262  
    2222#define FREEBOBDEVICEMANAGER_H 
    2323 
     24#include "configrom.h" 
     25 
    2426#include "debugmodule/debugmodule.h" 
    2527 
     
    3436typedef std::vector< IAvDevice* >::iterator IAvDeviceVectorIterator; 
    3537 
    36 typedef IAvDevice* (*ProbeFunction)(Ieee1394Service&, int, int); 
     38typedef IAvDevice* (*ProbeFunction)(Ieee1394Service&, ConfigRom&, int, int); 
    3739typedef std::vector<ProbeFunction> ProbeFunctionVector; 
    3840typedef std::vector<ProbeFunction>::iterator ProbeFunctionVectorIterator; 
     
    5961 
    6062protected: 
    61     static IAvDevice* probeBeBoB(Ieee1394Service& service, int id, int level); 
    62     static IAvDevice* probeBounce(Ieee1394Service& service, int id, int level); 
    63     static IAvDevice* probeMotu(Ieee1394Service& service, int id, int level); 
     63    static IAvDevice* probeBeBoB(Ieee1394Service& service, ConfigRom& configRom, int id, int level); 
     64    static IAvDevice* probeBounce(Ieee1394Service& service, ConfigRom& configRom, int id, int level); 
     65    static IAvDevice* probeMotu(Ieee1394Service& service, ConfigRom& configRom, int id, int level); 
    6466 
    6567protected: 
  • branches/libfreebob-2.0/src/motu/motu_avdevice.cpp

    r246 r262  
    3939IMPL_DEBUG_MODULE( MotuDevice, MotuDevice, DEBUG_LEVEL_NORMAL ); 
    4040 
     41char *motufw_modelname[] = {"[unknown]","828MkII", "Traveler"};  
     42 
    4143MotuDevice::MotuDevice( Ieee1394Service& ieee1394service, 
    4244                        int nodeId, 
    4345                        int verboseLevel ) 
    4446    : m_1394Service( &ieee1394service ) 
     47    , m_motu_model( MOTUFW_MODEL_NONE ) 
    4548    , m_nodeId( nodeId ) 
    4649    , m_verboseLevel( verboseLevel ) 
     
    7477MotuDevice::discover() 
    7578{ 
    76         signed int i, is_motu_fw_audio; 
    77  
    78         /* A list of all IEEE1394 Vendor IDs used by MOTU.  One would expect this to 
    79         * include only one, but stranger things have happened in this world.  The 
    80         * list is terminated with a 0xffffffff value. 
    81         */ 
    82         const unsigned int motu_vendor_ids[] = { 
    83                 VENDOR_MOTU, 
    84                 VENDOR_MOTU_TEST, 
    85                 0xffffffff, 
    86         }; 
    87          
    88         /* A list of all valid IEEE1394 model IDs for MOTU firewire audio devices, 
    89         * terminated by 0xffffffff. 
    90         */ 
    91         const unsigned int motu_fw_audio_model_ids[] = { 
    92                 MOTU_828mkII, MOTU_TRAVELER, MOTU_TEST, 
    93                 0xffffffff, 
    94         }; 
    95          
    96         /* Find out if this device is one we know about */ 
    97         is_motu_fw_audio = i = 0; 
    98  
    99         while ((motu_vendor_ids[i]!=0xffffffff)  
    100                         && (m_configRom->getVendorId() != motu_vendor_ids[i])) 
    101                 i++; 
    102  
    103         if (motu_vendor_ids[i] != 0xffffffff) { 
    104                 /* Device is made by MOTU.  See if the model is one we know about */ 
    105                 i = 0; 
    106  
    107                 while ((motu_fw_audio_model_ids[i]!=0xffffffff)  
    108                                 && (m_configRom->getModelId() != motu_fw_audio_model_ids[i])) 
    109                         i++; 
    110  
    111                 if (motu_fw_audio_model_ids[i]!=0xffffffff) 
    112                         is_motu_fw_audio = 1; 
    113         } 
    114  
    115         if (is_motu_fw_audio) { 
    116                 debugOutput( DEBUG_LEVEL_VERBOSE, "found %s %s\n", 
    117                         m_configRom->getVendorName(), m_configRom->getModelName()); 
    118                 return true; 
    119         } 
     79        // Find out if this device is one we know about 
     80        if (m_configRom->getUnitSpecifierId() == MOTUFW_VENDOR_MOTU) { 
     81                switch (m_configRom->getUnitVersion()) { 
     82                    case MOTUFW_UNITVER_828mkII:  
     83                        m_motu_model = MOTUFW_MODEL_828mkII;  
     84                        break; 
     85                    case MOTUFW_UNITVER_TRAVELER: 
     86                        m_motu_model = MOTUFW_MODEL_TRAVELER; 
     87                        break; 
     88                } 
     89        } 
     90        if (m_motu_model != MOTUFW_MODEL_NONE) { 
     91                debugOutput( DEBUG_LEVEL_VERBOSE, "found MOTU %s\n", 
     92                        motufw_modelname[m_motu_model]); 
     93                return true; 
     94        } 
    12095 
    12196    return false; 
     
    127102     Implement the procedure to retrieve the samplerate here 
    128103    */ 
    129     // FIXME:  
    130     return 44100; 
    131  
     104    quadlet_t q = ReadRegister(MOTUFW_REG_RATECTRL); 
     105    int rate = 0; 
     106 
     107    switch (q & ~MOTUFW_BASE_RATE_MASK) { 
     108        case MOTUFW_BASE_RATE_44100: 
     109            rate = 44100; 
     110            break; 
     111        case MOTUFW_BASE_RATE_48000: 
     112            rate = 48000; 
     113            break; 
     114    } 
     115    switch (q & ~MOTUFW_RATE_MULTIPLIER_MASK) { 
     116        case MOTUFW_RATE_MULTIPLIER_2X: 
     117            rate *= 2; 
     118            break; 
     119        case MOTUFW_RATE_MULTIPLIER_4X: 
     120            rate *= 4; 
     121            break; 
     122    } 
     123    return rate; 
    132124} 
    133125 
     
    142134        int supported=true; 
    143135 
    144         switch ( samplingFrequency ) { 
    145     case eSF_22050Hz: 
    146                 supported=false; 
    147         break; 
    148     case eSF_24000Hz: 
    149                 supported=false; 
    150         break; 
    151     case eSF_32000Hz: 
    152                 supported=false; 
    153         break; 
    154     case eSF_44100Hz: 
    155         new_rate = MOTU_BASE_RATE_44100 | MOTU_RATE_MULTIPLIER_1X; 
    156         break; 
    157     case eSF_48000Hz: 
    158         new_rate = MOTU_BASE_RATE_48000 | MOTU_RATE_MULTIPLIER_1X; 
    159         break; 
    160     case eSF_88200Hz: 
    161         new_rate = MOTU_BASE_RATE_44100 | MOTU_RATE_MULTIPLIER_2X; 
    162         break; 
    163     case eSF_96000Hz: 
    164         new_rate = MOTU_BASE_RATE_48000 | MOTU_RATE_MULTIPLIER_2X; 
    165         break; 
    166     case eSF_176400Hz: 
    167         new_rate = MOTU_BASE_RATE_44100 | MOTU_RATE_MULTIPLIER_4X; 
    168         break; 
    169     case eSF_192000Hz: 
    170         new_rate = MOTU_BASE_RATE_48000 | MOTU_RATE_MULTIPLIER_4X; 
    171         break; 
    172     default: 
    173         supported=false; 
    174     } 
    175  
    176         // update the register 
    177         if(supported) { 
    178                 quadlet_t value=ReadRegister(0x0B14); 
    179                 value &= ~(MOTU_RATE_MASK); 
    180                 value |= new_rate; 
    181  
    182                 if(WriteRegister(0x0B14,value) == 0) { 
    183                         supported=true; 
    184                 } else { 
    185                         supported=false; 
    186                 } 
    187         } 
    188  
     136    switch ( samplingFrequency ) { 
     137        case eSF_22050Hz: 
     138            supported=false; 
     139            break; 
     140        case eSF_24000Hz: 
     141            supported=false; 
     142            break; 
     143        case eSF_32000Hz: 
     144            supported=false; 
     145            break; 
     146        case eSF_44100Hz: 
     147            new_rate = MOTUFW_BASE_RATE_44100 | MOTUFW_RATE_MULTIPLIER_1X; 
     148            break; 
     149        case eSF_48000Hz: 
     150            new_rate = MOTUFW_BASE_RATE_48000 | MOTUFW_RATE_MULTIPLIER_1X; 
     151            break; 
     152        case eSF_88200Hz: 
     153            new_rate = MOTUFW_BASE_RATE_44100 | MOTUFW_RATE_MULTIPLIER_2X; 
     154            break; 
     155        case eSF_96000Hz: 
     156            new_rate = MOTUFW_BASE_RATE_48000 | MOTUFW_RATE_MULTIPLIER_2X; 
     157            break; 
     158        case eSF_176400Hz: 
     159            new_rate = MOTUFW_BASE_RATE_44100 | MOTUFW_RATE_MULTIPLIER_4X; 
     160            break; 
     161        case eSF_192000Hz: 
     162            new_rate = MOTUFW_BASE_RATE_48000 | MOTUFW_RATE_MULTIPLIER_4X; 
     163            break; 
     164        default: 
     165            supported=false; 
     166    } 
     167 
     168    // update the register.  FIXME: there's more to it than this 
     169    if (supported) { 
     170        quadlet_t value=ReadRegister(MOTUFW_REG_RATECTRL); 
     171        value &= ~(MOTUFW_BASE_RATE_MASK|MOTUFW_RATE_MULTIPLIER_MASK); 
     172        value |= new_rate; 
     173//        value |= 0x04000000; 
     174        if (WriteRegister(MOTUFW_REG_RATECTRL, value) == 0) { 
     175            supported=true; 
     176        } else { 
     177            supported=false; 
     178        } 
     179    } 
    189180    return supported; 
    190181} 
     
    199190MotuDevice::showDevice() const 
    200191{ 
    201     printf( "%s %s at node %d\n", 
    202                 m_configRom->getVendorName().c_str(),  
    203                 m_configRom->getModelName().c_str(), 
    204                 m_nodeId ); 
    205  
     192    printf( "MOTU %s at node %d\n", 
     193        motufw_modelname[m_motu_model], 
     194        m_nodeId ); 
    206195} 
    207196 
     
    471460 */ 
    472461 
    473        quadlet_t quadlet; 
    474        assert(m_1394Service); 
    475          
    476        quadlet = 0; 
    477         if (m_1394Service->read(m_nodeId, MOTU_BASE_ADDR+reg, 4, &quadlet) < 0) { 
    478                 debugError("Error doing motu read from register 0x%06x\n",reg); 
    479         } 
    480  
    481  
    482        return ntohl(quadlet); 
     462quadlet_t quadlet; 
     463assert(m_1394Service); 
     464         
     465  quadlet = 0; 
     466  // Note: 1394Service::read() expects a physical ID, not the node id 
     467  if (m_1394Service->read(0xffc0 | m_nodeId, MOTUFW_BASE_ADDR+reg, 4, &quadlet) < 0) { 
     468    debugError("Error doing motu read from register 0x%06x\n",reg); 
     469  } 
     470 
     471  return ntohl(quadlet); 
    483472} 
    484473 
     
    489478 
    490479  unsigned int err = 0; 
    491  
    492480  data = htonl(data); 
    493481 
    494   if (m_1394Service->write(m_nodeId, MOTU_BASE_ADDR+reg, 4, &data) < 0) { 
     482  // Note: 1394Service::write() expects a physical ID, not the node id 
     483  if (m_1394Service->write(0xffc0 | m_nodeId, MOTUFW_BASE_ADDR+reg, 4, &data) < 0) { 
    495484    err = 1; 
    496485    debugError("Error doing motu write to register 0x%06x\n",reg); 
     
    498487 
    499488  usleep(100); 
    500  
    501489  return (err==0)?0:-1; 
    502490} 
  • branches/libfreebob-2.0/src/motu/motu_avdevice.h

    r246 r262  
    3030#include "libstreaming/MotuStreamProcessor.h" 
    3131 
    32 #define MOTU_BASE_ADDR     0xfffff0000000ULL 
    33 #define MOTU_BASE_RATE_44100            (0<<4) 
    34 #define MOTU_BASE_RATE_48000            (1<<4) 
    35 #define MOTU_RATE_MULTIPLIER_1X         (0<<5) 
    36 #define MOTU_RATE_MULTIPLIER_2X         (1<<5) 
    37 #define MOTU_RATE_MULTIPLIER_4X         (2<<5) 
    38 #define MOTU_RATE_MASK                          (0x00000007) 
     32#define MOTUFW_BASE_ADDR     0xfffff0000000ULL 
     33#define MOTUFW_BASE_RATE_44100          (0<<3) 
     34#define MOTUFW_BASE_RATE_48000          (1<<3) 
     35#define MOTUFW_RATE_MULTIPLIER_1X       (0<<4) 
     36#define MOTUFW_RATE_MULTIPLIER_2X       (1<<4) 
     37#define MOTUFW_RATE_MULTIPLIER_4X       (2<<4) 
     38#define MOTUFW_BASE_RATE_MASK           (0x00000008) 
     39#define MOTUFW_RATE_MULTIPLIER_MASK     (0x00000030) 
     40 
     41/* Device registers */ 
     42#define MOTUFW_REG_RATECTRL             0x0b14 
    3943 
    4044 
     
    7276    virtual int stopStreamByIndex(int i); 
    7377 
     78    enum EMotuModel { 
     79      MOTUFW_MODEL_NONE     = 0x0000, 
     80      MOTUFW_MODEL_828mkII  = 0x0001, 
     81      MOTUFW_MODEL_TRAVELER = 0x0002, 
     82    }; 
     83 
    7484protected: 
    7585    Ieee1394Service* m_1394Service; 
    7686    ConfigRom*       m_configRom; 
     87    signed int       m_motu_model; 
    7788    int              m_nodeId; 
    7889    int              m_verboseLevel; 
     
    8798        signed int WriteRegister(unsigned int reg, quadlet_t data); 
    8899 
    89         /* ======================================================================= */ 
    90         /* MOTU-related defines, definitions, enumerations etc */ 
     100        // IEEE1394 Vendor IDs.  One would expect only MOTU, but you never 
     101        // know if a clone might appear some day. 
     102        enum EVendorId { 
     103                MOTUFW_VENDOR_MOTU = 0x000001f2, 
     104        }; 
     105         
     106        // IEEE1394 Unit directory version IDs for different MOTU hardware 
     107        enum EUnitVersionId { 
     108                MOTUFW_UNITVER_828mkII  = 0x00000003, 
     109                MOTUFW_UNITVER_TRAVELER = 0x00000009, 
     110        }; 
    91111 
    92         /* IEEE1394 Vendor IDs.  One would expect only MOTU, but you never know if a 
    93         * clone might appear some day. 
    94         */ 
    95         enum EVendorId { 
    96                 VENDOR_MOTU = 0x000001f2, 
    97                 VENDOR_MOTU_TEST     = 0x0000030D, 
    98         }; 
    99          
    100         /* IEEE1394 Model IDs for different MOTU hardware */ 
    101         enum EModelId { 
    102                 MOTU_828mkII  = 0x00101800, 
    103                 MOTU_TRAVELER = 0x00104800, 
    104                 MOTU_TEST     = 0x00000000, 
    105         }; 
    106  
    107         /* Input/Output channels.  Channels are included here even if they are 
    108         * uni-directional (eg: phones - which is output only).  It is up to 
    109         * individual functions taking a motufw_io_channel_t argument to ensure 
    110         * that operations are appropriate for the channel supplied. 
    111         */ 
    112         enum EIoChannel { 
    113                 MOTUFW_IO_ANALOG1, MOTUFW_IO_ANALOG2, MOTUFW_IO_ANALOG3, 
    114                 MOTUFW_IO_ANALOG4, MOTUFW_IO_ANALOG5, MOTUFW_IO_ANALOG6, 
    115                 MOTUFW_IO_ANALOG7, MOTUFW_IO_ANALOG8, 
    116                 MOTUFW_IO_AESEBU_L, MOTUFW_IO_AESEBU_R, /* Traveler only */ 
    117                 MOTUFW_IO_MAIN_L,   MOTUFW_IO_MAIN_R,   /* 828MkII only */ 
    118                 MOTUFW_IO_SPDIF_L,  MOTUFW_IO_SPDIF_R, 
    119                 MOTUFW_IO_ADAT1, MOTUFW_IO_ADAT2, MOTUFW_IO_ADAT3, 
    120                 MOTUFW_IO_ADAT4, MOTUFW_IO_ADAT5, MOTUFW_IO_ADAT6, 
    121                 MOTUFW_IO_ADAT7, MOTUFW_IO_ADAT8, 
    122         }; 
    123          
    124         /* Stereo output buses */ 
    125         enum EOutputBus { 
    126                 MOTUFW_OUTPUT_DISABLED , 
    127                 MOTUFW_OUTPUT_PHONES, 
    128                 MOTUFW_OUTPUT_ANALOG1_2, MOTUFW_OUTPUT_ANALOG3_4, 
    129                 MOTUFW_OUTPUT_ANALOG5_6, MOTUFW_OUTPUT_ANALOG7_8, 
    130                 MOTUFW_OUTPUT_AESEBU, MOTUFW_OUTPUT_MAINPOUT, 
    131                 MOTUFW_OUTPUT_SPDIF, 
    132                 MOTUFW_OUTPUT_ADAT1_2, MOTUFW_OUTPUT_ADAT3_4, 
    133                 MOTUFW_OUTPUT_ADAT5_6, MOTUFW_OUTPUT_ADAT7_8, 
    134         }; 
    135          
    136         /* Cuemix mixers available */ 
    137         enum ECuemixMixer { 
    138                 MOTUFW_CUEMIX_MIX1, 
    139                 MOTUFW_CUEMIX_MIX2, 
    140                 MOTUFW_CUEMIX_MIX3, 
    141                 MOTUFW_CUEMIX_MIX4, 
    142         }; 
    143          
    144         /* MOTU configuration details */ 
    145         enum ESampleRate { 
    146                 MOTUFW_SAMPLERATE_44k1,  MOTUFW_SAMPLERATE_48k, 
    147                 MOTUFW_SAMPLERATE_88k2,  MOTUFW_SAMPLERATE_96k, 
    148                 MOTUFW_SAMPLERATE_176k4, MOTUFW_SAMPLERATE_192k, 
    149         }; 
    150          
    151         enum EClockSource { 
    152                 MOTUFW_CLOCKSOURCE_INT, 
    153                 MOTUFW_CLOCKSOURCE_SMPTE, 
    154                 MOTUFW_CLOCKSOURCE_AESEBU, 
    155                 MOTUFW_CLOCKSOURCE_SPDIF, 
    156                 MOTUFW_CLOCKSOURCE_TOSLINK, 
    157                 MOTUFW_CLOCKSOURCE_WORDCLOCK, 
    158                 MOTUFW_CLOCKSOURCE_ADAT_9PIN, 
    159                 MOTUFW_CLOCKSOURCE_ADAT_OPTICAL, 
    160         }; 
    161          
    162         enum ERefLevel{ 
    163                 MOTUFW_REFLEVEL_PLUS4_DBU, MOTUFW_REFLEVEL_MINUS10_DBU, 
    164         }; 
    165          
    166         enum EOpticalMode { 
    167                 MOTUFW_OPTICAL_MODE_OFF, 
    168                 MOTUFW_OPTICAL_MODE_ADAT, 
    169                 MOTUFW_OPTICAL_MODE_TOSLINK, 
    170         }; 
    171  
    172  
    173         // debug support 
     112    // debug support 
    174113    DECLARE_DEBUG_MODULE; 
    175114}; 
  • branches/libfreebob-2.0/tests/Makefile.am

    r244 r262  
    2121        $(LIBAVC1394_CFLAGS) 
    2222 
    23 noinst_PROGRAMS = # test-freebob test-extplugcmd freebob-server 
     23# noinst_PROGRAMS = # test-freebob test-extplugcmd freebob-server 
     24noinst_PROGRAMS = test-freebob 
    2425noinst_HEADERS =  
    2526 
    26 # test_freebob_SOURCES = test-freebob.c 
    27 # test_freebob_LDADD   = $(top_builddir)/src/libfreebob.la \ 
    28 #     $(LIBXML_LIBS) $(LIBAVC1394_LIBS) $(LIBIEC61883_LIBS) 
     27test_freebob_SOURCES = test-freebob.c 
     28test_freebob_LDADD   = $(top_builddir)/src/libfreebob.la \ 
     29      $(LIBXML_LIBS) $(LIBAVC1394_LIBS) $(LIBIEC61883_LIBS) 
    2930#  
    3031# test_extplugcmd_SOURCES = test-extplugcmd.cpp