Changeset 1284

Show
Ignore:
Timestamp:
07/10/08 04:33:34 (13 years ago)
Author:
ppalmers
Message:

rewrite the audiofire mixer, is now generic for all audiofire devices

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/libffado-2.0/src/fireworks/efc/efc_cmds_hardware.h

    r864 r1284  
    5353    virtual void showEfcCmd(); 
    5454     
    55     bool hasSoftwarePhantom() 
     55    bool hasSoftwarePhantom() const 
    5656        {return EFC_CMD_HW_CHECK_FLAG(m_flags, EFC_CMD_HW_HAS_PHANTOM);}; 
    57     bool hasDSP() 
     57    bool hasDSP() const 
    5858        {return EFC_CMD_HW_CHECK_FLAG(m_flags, EFC_CMD_HW_HAS_DSP);}; 
    59     bool hasFPGA() 
     59    bool hasFPGA() const 
    6060        {return EFC_CMD_HW_CHECK_FLAG(m_flags, EFC_CMD_HW_HAS_FPGA);}; 
    61     bool hasSpdifCoax() 
     61    bool hasSpdifCoax() const 
    6262        {return EFC_CMD_HW_CHECK_FLAG(m_flags, EFC_CMD_HW_SPDIF_COAX_SUPPORTED);}; 
    63     bool hasSpdifAESEBUXLR() 
     63    bool hasSpdifAESEBUXLR() const 
    6464        {return EFC_CMD_HW_CHECK_FLAG(m_flags, EFC_CMD_HW_SPDIF_AESEBUXLR_SUPPORTED);}; 
    65     bool hasMirroring() 
     65    bool hasMirroring() const 
    6666        {return EFC_CMD_HW_CHECK_FLAG(m_flags, EFC_CMD_HW_MIRRORING_SUPPORTED);}; 
    67     bool hasDynAddr() 
     67    bool hasDynAddr() const 
    6868        {return EFC_CMD_HW_CHECK_FLAG(m_flags, EFC_CMD_HW_DYNADDR_SUPPORTED);}; 
    6969 
  • branches/libffado-2.0/src/fireworks/efc/efc_cmds_hardware_ctrl.cpp

    r1136 r1284  
    166166} 
    167167 
     168// -- get flags  
     169EfcGetFlagsCmd::EfcGetFlagsCmd() 
     170    : EfcCmd(EFC_CAT_HARDWARE_CONTROL, EFC_CMD_HWCTRL_GET_FLAGS) 
     171    , m_flags ( 0 ) 
     172{ 
     173} 
     174 
     175bool 
     176EfcGetFlagsCmd::serialize( Util::Cmd::IOSSerialize& se ) 
     177{ 
     178    bool result=true; 
     179 
     180    // the length should be specified before 
     181    // the header is serialized 
     182    m_length=EFC_HEADER_LENGTH_QUADLETS; 
     183 
     184    result &= EfcCmd::serialize ( se ); 
     185 
     186    return result; 
     187} 
     188 
     189bool 
     190EfcGetFlagsCmd::deserialize( Util::Cmd::IISDeserialize& de ) 
     191{ 
     192    bool result=true; 
     193 
     194    result &= EfcCmd::deserialize ( de ); 
     195 
     196    EFC_DESERIALIZE_AND_SWAP(de, &m_flags, result); 
     197 
     198    return result; 
     199} 
     200 
     201void 
     202EfcGetFlagsCmd::showEfcCmd() 
     203{ 
     204    EfcCmd::showEfcCmd(); 
     205    debugOutput(DEBUG_LEVEL_NORMAL, "EFC Get Flags:\n"); 
     206    debugOutput(DEBUG_LEVEL_NORMAL, " Flags       : %08X\n", m_flags); 
     207} 
     208 
     209// ---- 
     210EfcChangeFlagsCmd::EfcChangeFlagsCmd() 
     211    : EfcCmd(EFC_CAT_HARDWARE_CONTROL, EFC_CMD_HWCTRL_CHANGE_FLAGS) 
     212    , m_setmask ( 0 ) 
     213    , m_clearmask ( 0 ) 
     214{ 
     215} 
     216 
     217bool 
     218EfcChangeFlagsCmd::serialize( Util::Cmd::IOSSerialize& se ) 
     219{ 
     220    bool result=true; 
     221 
     222    // the length should be specified before 
     223    // the header is serialized 
     224    m_length=EFC_HEADER_LENGTH_QUADLETS+2; 
     225 
     226    result &= EfcCmd::serialize ( se ); 
     227 
     228    result &= se.write(CondSwapToBus32(m_setmask), "SetMask" ); 
     229    result &= se.write(CondSwapToBus32(m_clearmask), "ClearMask" ); 
     230 
     231    return result; 
     232} 
     233 
     234bool 
     235EfcChangeFlagsCmd::deserialize( Util::Cmd::IISDeserialize& de ) 
     236{ 
     237    bool result=true; 
     238    result &= EfcCmd::deserialize ( de ); 
     239    return result; 
     240} 
     241 
     242void 
     243EfcChangeFlagsCmd::showEfcCmd() 
     244{ 
     245    EfcCmd::showEfcCmd(); 
     246    debugOutput(DEBUG_LEVEL_NORMAL, "EFC Change flags:\n"); 
     247    debugOutput(DEBUG_LEVEL_NORMAL, " Set mask     : %08X\n", m_setmask); 
     248    debugOutput(DEBUG_LEVEL_NORMAL, " Clear mask   : %08X\n", m_clearmask); 
     249} 
     250 
     251 
     252// ---- 
     253EfcIdentifyCmd::EfcIdentifyCmd() 
     254    : EfcCmd(EFC_CAT_HARDWARE_CONTROL, EFC_CMD_HWCTRL_IDENTIFY) 
     255{ 
     256} 
     257 
     258bool 
     259EfcIdentifyCmd::serialize( Util::Cmd::IOSSerialize& se ) 
     260{ 
     261    bool result=true; 
     262 
     263    // the length should be specified before 
     264    // the header is serialized 
     265    m_length=EFC_HEADER_LENGTH_QUADLETS; 
     266 
     267    result &= EfcCmd::serialize ( se ); 
     268 
     269    return result; 
     270} 
     271 
     272bool 
     273EfcIdentifyCmd::deserialize( Util::Cmd::IISDeserialize& de ) 
     274{ 
     275    bool result=true; 
     276 
     277    result &= EfcCmd::deserialize ( de ); 
     278 
     279    return result; 
     280} 
     281 
     282void 
     283EfcIdentifyCmd::showEfcCmd() 
     284{ 
     285    EfcCmd::showEfcCmd(); 
     286    debugOutput(DEBUG_LEVEL_NORMAL, "EFC Identify\n"); 
     287} 
     288 
    168289} // namespace FireWorks 
  • branches/libffado-2.0/src/fireworks/efc/efc_cmds_hardware_ctrl.h

    r864 r1284  
    2828 
    2929namespace FireWorks { 
     30 
     31#define FIREWORKS_EFC_FLAG_MIXER_ENABLED    1 
     32#define FIREWORKS_EFC_FLAG_SPDIF_PRO        2 
     33#define FIREWORKS_EFC_FLAG_SPDIF_RAW        4 
    3034 
    3135class EfcGetClockCmd : public EfcCmd 
     
    8286}; 
    8387 
     88 
     89class EfcGetFlagsCmd : public EfcCmd 
     90{ 
     91public: 
     92    EfcGetFlagsCmd(); 
     93    virtual ~EfcGetFlagsCmd() {}; 
     94 
     95    virtual bool serialize( Util::Cmd::IOSSerialize& se ); 
     96    virtual bool deserialize( Util::Cmd::IISDeserialize& de ); 
     97 
     98    virtual const char* getCmdName() const 
     99    { return "EfcGetFlagsCmd"; } 
     100 
     101    virtual void showEfcCmd(); 
     102 
     103    uint32_t    m_flags; 
     104}; 
     105 
     106class EfcChangeFlagsCmd : public EfcCmd 
     107{ 
     108public: 
     109    EfcChangeFlagsCmd(); 
     110    virtual ~EfcChangeFlagsCmd() {}; 
     111 
     112    virtual bool serialize( Util::Cmd::IOSSerialize& se ); 
     113    virtual bool deserialize( Util::Cmd::IISDeserialize& de ); 
     114 
     115    virtual const char* getCmdName() const 
     116    { return "EfcChangeFlagsCmd"; } 
     117 
     118    virtual void showEfcCmd(); 
     119 
     120    uint32_t    m_setmask; 
     121    uint32_t    m_clearmask; 
     122}; 
     123 
     124class EfcIdentifyCmd : public EfcCmd 
     125{ 
     126public: 
     127    EfcIdentifyCmd(); 
     128    virtual ~EfcIdentifyCmd() {}; 
     129 
     130    virtual bool serialize( Util::Cmd::IOSSerialize& se ); 
     131    virtual bool deserialize( Util::Cmd::IISDeserialize& de ); 
     132 
     133    virtual const char* getCmdName() const 
     134    { return "EfcIdentifyCmd"; } 
     135 
     136    virtual void showEfcCmd(); 
     137 
     138}; 
     139 
    84140} // namespace FireWorks 
    85141 
  • branches/libffado-2.0/src/fireworks/fireworks_control.cpp

    r1158 r1284  
    2828#include "efc/efc_cmds_mixer.h" 
    2929#include "efc/efc_cmds_monitor.h" 
     30#include "efc/efc_cmds_hardware_ctrl.h" 
    3031 
    3132#include <string> 
     
    4041: Control::MatrixMixer(&p, "MonitorControl") 
    4142, m_control(c) 
    42 , m_Parent(p) 
     43, m_ParentDevice(p) 
    4344{ 
    4445} 
     
    4748: Control::MatrixMixer(&p, n) 
    4849, m_control(c) 
    49 , m_Parent(p) 
     50, m_ParentDevice(p) 
    5051{ 
    5152} 
     
    8687    bool did_command=false; 
    8788 
    88     if(row >= (int)m_Parent.getHwInfo().m_nb_phys_audio_in) { 
     89    if(row >= (int)m_ParentDevice.getHwInfo().m_nb_phys_audio_in) { 
    8990        debugError("specified row (%u) larger than number of rows (%d)\n", 
    90             row, m_Parent.getHwInfo().m_nb_phys_audio_in); 
     91            row, m_ParentDevice.getHwInfo().m_nb_phys_audio_in); 
    9192        return 0.0; 
    9293    } 
    93     if(col >= (int)m_Parent.getHwInfo().m_nb_phys_audio_out) { 
     94    if(col >= (int)m_ParentDevice.getHwInfo().m_nb_phys_audio_out) { 
    9495        debugError("specified col (%u) larger than number of cols (%d)\n", 
    95             col, m_Parent.getHwInfo().m_nb_phys_audio_out); 
     96            col, m_ParentDevice.getHwInfo().m_nb_phys_audio_out); 
    9697        return 0.0; 
    9798    } 
    9899 
     100    // not a switch since we create variables 
    99101    if(m_control==eMC_Gain) { 
    100102        EfcSetMonitorGainCmd setCmd; 
    101         setCmd.m_input=row; 
    102         setCmd.m_output=col; 
    103         setCmd.m_value=(uint32_t)val; 
    104         if (!m_Parent.doEfcOverAVC(setCmd))  
    105         { 
    106             debugFatal("Cmd failed\n"); 
    107         } 
    108         retval=setCmd.m_value; 
    109         did_command=true; 
     103        setCmd.m_input = row; 
     104        setCmd.m_output = col; 
     105        setCmd.m_value = (uint32_t)val; 
     106        if (!m_ParentDevice.doEfcOverAVC(setCmd))  
     107        { 
     108            debugError("Cmd failed\n"); 
     109        } 
     110        // update the session block 
     111        m_ParentDevice.m_session.h.monitorgains[row][col] = setCmd.m_value; 
     112        retval = setCmd.m_value; 
     113        did_command = true; 
    110114    } 
    111115    if(m_control==eMC_Pan) { 
    112116        EfcSetMonitorPanCmd setCmd; 
    113         setCmd.m_input=row; 
    114         setCmd.m_output=col; 
    115         setCmd.m_value=(uint32_t)val; 
    116         if (!m_Parent.doEfcOverAVC(setCmd))  
    117         { 
    118             debugFatal("Cmd failed\n"); 
    119         } 
    120         retval=setCmd.m_value; 
    121         did_command=true; 
     117        setCmd.m_input = row; 
     118        setCmd.m_output = col; 
     119        setCmd.m_value = (uint32_t)val; 
     120        if (!m_ParentDevice.doEfcOverAVC(setCmd))  
     121        { 
     122            debugError("Cmd failed\n"); 
     123        } 
     124        // update the session block 
     125        m_ParentDevice.m_session.s.monitorpans[row][col] = setCmd.m_value; 
     126        retval = setCmd.m_value; 
     127        did_command = true; 
    122128    } 
    123129    if(m_control==eMC_Mute) { 
    124130        EfcSetMonitorMuteCmd setCmd; 
    125         setCmd.m_input=row; 
    126         setCmd.m_output=col; 
    127         setCmd.m_value=(uint32_t)val; 
    128         if (!m_Parent.doEfcOverAVC(setCmd))  
    129         { 
    130             debugFatal("Cmd failed\n"); 
    131         } 
    132         retval=setCmd.m_value; 
    133         did_command=true; 
     131        setCmd.m_input = row; 
     132        setCmd.m_output = col; 
     133        setCmd.m_value = (uint32_t)val; 
     134        if (!m_ParentDevice.doEfcOverAVC(setCmd)) 
     135        { 
     136            debugError("Cmd failed\n"); 
     137        } 
     138        // update the session block 
     139        if(setCmd.m_value) { 
     140            m_ParentDevice.m_session.s.monitorflags[row][col] |= ECHO_SESSION_MUTE_BIT; 
     141        } else { 
     142            m_ParentDevice.m_session.s.monitorflags[row][col] &= ~ECHO_SESSION_MUTE_BIT; 
     143        } 
     144        retval = setCmd.m_value; 
     145        did_command = true; 
    134146    } 
    135147    if(m_control==eMC_Solo) { 
    136148        EfcSetMonitorSoloCmd setCmd; 
    137         setCmd.m_input=row; 
    138         setCmd.m_output=col; 
    139         setCmd.m_value=(uint32_t)val; 
    140         if (!m_Parent.doEfcOverAVC(setCmd))  
    141         { 
    142             debugFatal("Cmd failed\n"); 
    143         } 
    144         retval=setCmd.m_value; 
    145         did_command=true; 
     149        setCmd.m_input = row; 
     150        setCmd.m_output = col; 
     151        setCmd.m_value = (uint32_t)val; 
     152        if (!m_ParentDevice.doEfcOverAVC(setCmd))  
     153        { 
     154            debugError("Cmd failed\n"); 
     155        } 
     156        // update the session block 
     157        if(setCmd.m_value) { 
     158            m_ParentDevice.m_session.s.monitorflags[row][col] |= ECHO_SESSION_SOLO_BIT; 
     159        } else { 
     160            m_ParentDevice.m_session.s.monitorflags[row][col] &= ~ECHO_SESSION_SOLO_BIT; 
     161        } 
     162        retval = setCmd.m_value; 
     163        did_command = true; 
    146164    } 
    147165 
     
    160178    bool did_command=false; 
    161179 
    162     if(row >= (int)m_Parent.getHwInfo().m_nb_phys_audio_in) { 
     180    if(row >= (int)m_ParentDevice.getHwInfo().m_nb_phys_audio_in) { 
    163181        debugError("specified row (%u) larger than number of rows (%d)\n", 
    164             row, m_Parent.getHwInfo().m_nb_phys_audio_in); 
     182            row, m_ParentDevice.getHwInfo().m_nb_phys_audio_in); 
    165183        return 0.0; 
    166184    } 
    167     if(col >= (int)m_Parent.getHwInfo().m_nb_phys_audio_out) { 
     185    if(col >= (int)m_ParentDevice.getHwInfo().m_nb_phys_audio_out) { 
    168186        debugError("specified col (%u) larger than number of cols (%d)\n", 
    169             col, m_Parent.getHwInfo().m_nb_phys_audio_out); 
     187            col, m_ParentDevice.getHwInfo().m_nb_phys_audio_out); 
    170188        return 0.0; 
    171189    } 
     
    175193        getCmd.m_input=row; 
    176194        getCmd.m_output=col; 
    177         if (!m_Parent.doEfcOverAVC(getCmd))  
    178         { 
    179             debugFatal("Cmd failed\n"); 
     195        if (!m_ParentDevice.doEfcOverAVC(getCmd))  
     196        { 
     197            debugError("Cmd failed\n"); 
    180198        } 
    181199        retval=getCmd.m_value; 
     
    186204        getCmd.m_input=row; 
    187205        getCmd.m_output=col; 
    188         if (!m_Parent.doEfcOverAVC(getCmd))  
    189         { 
    190             debugFatal("Cmd failed\n"); 
     206        if (!m_ParentDevice.doEfcOverAVC(getCmd))  
     207        { 
     208            debugError("Cmd failed\n"); 
    191209        } 
    192210        retval=getCmd.m_value; 
     
    197215        getCmd.m_input=row; 
    198216        getCmd.m_output=col; 
    199         if (!m_Parent.doEfcOverAVC(getCmd))  
    200         { 
    201             debugFatal("Cmd failed\n"); 
     217        if (!m_ParentDevice.doEfcOverAVC(getCmd))  
     218        { 
     219            debugError("Cmd failed\n"); 
    202220        } 
    203221        retval=getCmd.m_value; 
     
    208226        getCmd.m_input=row; 
    209227        getCmd.m_output=col; 
    210         if (!m_Parent.doEfcOverAVC(getCmd))  
    211         { 
    212             debugFatal("Cmd failed\n"); 
     228        if (!m_ParentDevice.doEfcOverAVC(getCmd))  
     229        { 
     230            debugError("Cmd failed\n"); 
    213231        } 
    214232        retval=getCmd.m_value; 
     
    227245int MonitorControl::getRowCount( ) 
    228246{ 
    229     return m_Parent.getHwInfo().m_nb_phys_audio_in; 
     247    return m_ParentDevice.getHwInfo().m_nb_phys_audio_in; 
    230248} 
    231249 
    232250int MonitorControl::getColCount( ) 
    233251{ 
    234     return m_Parent.getHwInfo().m_nb_phys_audio_out; 
     252    return m_ParentDevice.getHwInfo().m_nb_phys_audio_out; 
    235253} 
    236254 
     
    243261: Control::Continuous(&p, "SimpleControl") 
    244262, m_Slave(new EfcGenericMixerCmd(t, c, channel)) 
    245 , m_Parent(p) 
     263, m_ParentDevice(p) 
    246264{ 
    247265} 
     
    254272: Control::Continuous(&p, n) 
    255273, m_Slave(new EfcGenericMixerCmd(t, c, channel)) 
    256 , m_Parent(p) 
     274, m_ParentDevice(p) 
    257275{ 
    258276} 
     
    273291    if(m_Slave) { 
    274292        m_Slave->setType(eCT_Set); 
    275         m_Slave->m_value=(uint32_t)val; 
    276         if (!m_Parent.doEfcOverAVC(*m_Slave))  
    277         { 
    278             debugFatal("Cmd failed\n"); 
     293        m_Slave->m_value = (uint32_t)val; 
     294        if (!m_ParentDevice.doEfcOverAVC(*m_Slave))  
     295        { 
     296            debugError("Cmd failed\n"); 
    279297            return 0.0; 
     298        } 
     299 
     300        // update the session block 
     301        switch(m_Slave->getTarget()) { 
     302        case eMT_PlaybackMix: 
     303            switch(m_Slave->getType()) { 
     304            case eMC_Gain: 
     305                m_ParentDevice.m_session.h.playbackgains[m_Slave->m_channel] = m_Slave->m_value; 
     306                break; 
     307            default: // nothing 
     308                break; 
     309            } 
     310            break; 
     311        case eMT_PhysicalOutputMix: 
     312            switch(m_Slave->getType()) { 
     313            case eMC_Gain: 
     314                m_ParentDevice.m_session.h.outputgains[m_Slave->m_channel] = m_Slave->m_value; 
     315                break; 
     316            default: // nothing 
     317                break; 
     318            } 
     319            break; 
     320        default: // nothing 
     321            break; 
    280322        } 
    281323        debugOutput(DEBUG_LEVEL_VERBOSE, "setValue for channel %d to %lf = %lf\n",  
     
    292334    if(m_Slave) { 
    293335        m_Slave->setType(eCT_Get); 
    294         if (!m_Parent.doEfcOverAVC(*m_Slave))  
    295         { 
    296             debugFatal("Cmd failed\n"); 
     336        if (!m_ParentDevice.doEfcOverAVC(*m_Slave))  
     337        { 
     338            debugError("Cmd failed\n"); 
    297339            return 0.0; 
    298340        } 
     
    315357, m_bit(bit) 
    316358, m_Slave(new EfcGenericMixerCmd(t, c, channel)) 
    317 , m_Parent(p) 
     359, m_ParentDevice(p) 
    318360{ 
    319361} 
     
    327369, m_bit(bit) 
    328370, m_Slave(new EfcGenericMixerCmd(t, c, channel)) 
    329 , m_Parent(p) 
     371, m_ParentDevice(p) 
    330372{ 
    331373} 
     
    361403        m_Slave->setType(eCT_Set); 
    362404        m_Slave->m_value=reg; 
    363         if (!m_Parent.doEfcOverAVC(*m_Slave))  
    364         { 
    365             debugFatal("Cmd failed\n"); 
     405        if (!m_ParentDevice.doEfcOverAVC(*m_Slave))  
     406        { 
     407            debugError("Cmd failed\n"); 
    366408            return 0; 
    367409        } 
     410 
     411        // update the session block 
     412        switch(m_Slave->getTarget()) { 
     413        case eMT_PlaybackMix: 
     414            switch(m_Slave->getType()) { 
     415            case eMC_Mute: 
     416                m_ParentDevice.m_session.s.playbacks[m_Slave->m_channel].mute = m_Slave->m_value; 
     417                break; 
     418            case eMC_Solo: 
     419                m_ParentDevice.m_session.s.playbacks[m_Slave->m_channel].solo = m_Slave->m_value; 
     420                break; 
     421            default: // nothing 
     422                break; 
     423            } 
     424            break; 
     425        case eMT_PhysicalOutputMix: 
     426            switch(m_Slave->getType()) { 
     427            case eMC_Mute: 
     428                m_ParentDevice.m_session.s.outputs[m_Slave->m_channel].mute = m_Slave->m_value; 
     429                break; 
     430            case eMC_Nominal: 
     431                m_ParentDevice.m_session.s.outputs[m_Slave->m_channel].shift = m_Slave->m_value; 
     432                break; 
     433            default: // nothing 
     434                break; 
     435            } 
     436            break; 
     437        case eMT_PhysicalInputMix: 
     438            switch(m_Slave->getType()) { 
     439            //case eMC_Pad: 
     440            //    m_ParentDevice.m_session.s.inputs[m_Slave->m_channel].pad = m_Slave->m_value; 
     441            //    break; 
     442            case eMC_Nominal: 
     443                m_ParentDevice.m_session.s.inputs[m_Slave->m_channel].shift = m_Slave->m_value; 
     444                break; 
     445            default: // nothing 
     446                break; 
     447            } 
     448            break; 
     449        default: // nothing 
     450            break; 
     451        } 
     452 
    368453        debugOutput(DEBUG_LEVEL_VERBOSE, "setValue for channel %d to %ld (reg: 0x%08X => 0x%08X)\n",  
    369454                                            m_Slave->m_channel, val, old_reg, reg); 
     
    379464    if(m_Slave) { 
    380465        m_Slave->setType(eCT_Get); 
    381         if (!m_Parent.doEfcOverAVC(*m_Slave))  
    382         { 
    383             debugFatal("Cmd failed\n"); 
     466        if (!m_ParentDevice.doEfcOverAVC(*m_Slave))  
     467        { 
     468            debugError("Cmd failed\n"); 
    384469            return 0; 
    385470        } 
     
    394479} 
    395480 
     481// --- control element for flags 
     482 
     483SpdifModeControl::SpdifModeControl(FireWorks::Device& parent) 
     484: Control::Discrete(&parent, "SpdifModeControl") 
     485, m_ParentDevice(parent) 
     486{ 
     487} 
     488 
     489SpdifModeControl::SpdifModeControl(FireWorks::Device& parent, 
     490                                   std::string n) 
     491: Control::Discrete(&parent, n) 
     492, m_ParentDevice(parent) 
     493{ 
     494} 
     495 
     496SpdifModeControl::~SpdifModeControl() 
     497{ 
     498} 
     499 
     500void SpdifModeControl::show() 
     501{ 
     502    debugOutput(DEBUG_LEVEL_NORMAL, "SpdifModeControl\n"); 
     503} 
     504 
     505bool SpdifModeControl::setValue( const int val ) 
     506{ 
     507    EfcChangeFlagsCmd setCmd; 
     508    if(val) { 
     509        setCmd.m_setmask = FIREWORKS_EFC_FLAG_SPDIF_PRO; 
     510    } else { 
     511        setCmd.m_clearmask = FIREWORKS_EFC_FLAG_SPDIF_PRO; 
     512    } 
     513    debugOutput(DEBUG_LEVEL_VERBOSE, "setValue val: %d setmask: %08X, clear: %08X\n",  
     514                                      val, setCmd.m_setmask, setCmd.m_clearmask); 
     515    if (!m_ParentDevice.doEfcOverAVC(setCmd)) 
     516    { 
     517        debugError("Cmd failed\n"); 
     518        return false; 
     519    } 
     520    return true; 
     521} 
     522 
     523int SpdifModeControl::getValue( ) 
     524{ 
     525    EfcGetFlagsCmd getCmd; 
     526    if (!m_ParentDevice.doEfcOverAVC(getCmd)) 
     527    { 
     528        debugError("Cmd failed\n"); 
     529        return 0; 
     530    } 
     531    debugOutput(DEBUG_LEVEL_VERBOSE, "got flags: %08X\n",  
     532                                      getCmd.m_flags); 
     533    if(getCmd.m_flags & FIREWORKS_EFC_FLAG_SPDIF_PRO) return 1; 
     534    else return 0; 
     535} 
     536 
    396537// --- io config controls 
    397538 
     
    400541: Control::Discrete(&parent, "IOConfigControl") 
    401542, m_Slave(new EfcGenericIOConfigCmd(r)) 
    402 , m_Parent(parent) 
     543, m_ParentDevice(parent) 
    403544{ 
    404545} 
     
    409550: Control::Discrete(&parent, n) 
    410551, m_Slave(new EfcGenericIOConfigCmd(r)) 
    411 , m_Parent(parent) 
     552, m_ParentDevice(parent) 
    412553{ 
    413554} 
     
    429570        m_Slave->setType(eCT_Set); 
    430571        m_Slave->m_value=val; 
    431         if (!m_Parent.doEfcOverAVC(*m_Slave))  
    432         { 
    433             debugFatal("Cmd failed\n"); 
     572        if (!m_ParentDevice.doEfcOverAVC(*m_Slave))  
     573        { 
     574            debugError("Cmd failed\n"); 
    434575            return 0; 
    435576        } 
     
    446587    if(m_Slave) { 
    447588        m_Slave->setType(eCT_Get); 
    448         if (!m_Parent.doEfcOverAVC(*m_Slave))  
    449         { 
    450             debugFatal("Cmd failed\n"); 
     589        if (!m_ParentDevice.doEfcOverAVC(*m_Slave))  
     590        { 
     591            debugError("Cmd failed\n"); 
    451592            return 0; 
    452593        } 
     
    460601} 
    461602 
    462  
     603// control to get hardware information 
     604HwInfoControl::HwInfoControl(FireWorks::Device& p, 
     605                             enum eHwInfoField f) 
     606: Control::Discrete(&p, "HwInfoControl") 
     607, m_ParentDevice(p) 
     608, m_Field(f) 
     609
     610
     611 
     612HwInfoControl::HwInfoControl(FireWorks::Device& p, 
     613                             enum eHwInfoField f, 
     614                             std::string n) 
     615: Control::Discrete(&p, n) 
     616, m_ParentDevice(p) 
     617, m_Field(f) 
     618
     619
     620 
     621HwInfoControl::~HwInfoControl() 
     622
     623
     624 
     625int HwInfoControl::getValue() 
     626
     627    switch (m_Field) { 
     628        case eHIF_PhysicalAudioOutCount: 
     629            return m_ParentDevice.getHwInfo().m_nb_phys_audio_out; 
     630        case eHIF_PhysicalAudioInCount: 
     631            return m_ParentDevice.getHwInfo().m_nb_phys_audio_in; 
     632        case eHIF_1394PlaybackCount: 
     633            return m_ParentDevice.getHwInfo().m_nb_1394_playback_channels; 
     634        case eHIF_1394RecordCount: 
     635            return m_ParentDevice.getHwInfo().m_nb_1394_record_channels; 
     636        case eHIF_GroupOutCount: 
     637            return m_ParentDevice.getHwInfo().m_nb_out_groups; 
     638        case eHIF_GroupInCount: 
     639            return m_ParentDevice.getHwInfo().m_nb_in_groups; 
     640        case eHIF_PhantomPower: 
     641            return m_ParentDevice.getHwInfo().hasSoftwarePhantom(); 
     642        default: 
     643            debugError("Bogus field\n"); 
     644            return 0; 
     645    } 
     646
     647 
     648void HwInfoControl::show() 
     649
     650    debugOutput(DEBUG_LEVEL_NORMAL, "HwInfoControl\n"); 
     651
     652 
     653 
     654// control to save settings 
     655MultiControl::MultiControl(FireWorks::Device& p, enum eType t) 
     656: Control::Discrete(&p, "MultiControl") 
     657, m_ParentDevice(p) 
     658, m_Type(t) 
     659
     660
     661 
     662MultiControl::MultiControl(FireWorks::Device& p, 
     663                           enum eType t, std::string n) 
     664: Control::Discrete(&p, n) 
     665, m_ParentDevice(p) 
     666, m_Type(t) 
     667
     668
     669 
     670MultiControl::~MultiControl() 
     671
     672
     673 
     674bool MultiControl::setValue(const int v) 
     675
     676    switch(m_Type) { 
     677    case eT_SaveSession: 
     678        debugOutput(DEBUG_LEVEL_VERBOSE, "saving session\n"); 
     679        return m_ParentDevice.saveSession(); 
     680    case eT_Identify: 
     681        debugOutput(DEBUG_LEVEL_VERBOSE, "indentify device\n"); 
     682        { 
     683            EfcIdentifyCmd cmd; 
     684            if (!m_ParentDevice.doEfcOverAVC(cmd))  
     685            { 
     686                debugError("Cmd failed\n"); 
     687                return false; 
     688            } 
     689        } 
     690        return true; 
     691    default: 
     692        debugError("Bad type\n"); 
     693        return false; 
     694    } 
     695
     696 
     697void MultiControl::show() 
     698
     699    debugOutput(DEBUG_LEVEL_NORMAL, "MultiControl\n"); 
     700    switch(m_Type) { 
     701    case eT_SaveSession: 
     702        debugOutput(DEBUG_LEVEL_NORMAL, "Type: SaveSession\n"); 
     703        break; 
     704    case eT_Identify: 
     705        debugOutput(DEBUG_LEVEL_NORMAL, "Type: Identify\n"); 
     706        break; 
     707    default: 
     708        debugError("Bad type\n"); 
     709    } 
     710
    463711 
    464712} // FireWorks 
  • branches/libffado-2.0/src/fireworks/fireworks_control.h

    r1158 r1284  
    7171protected: 
    7272    enum eMonitorControl        m_control; 
    73     FireWorks::Device&          m_Parent
     73    FireWorks::Device&          m_ParentDevice
    7474}; 
    7575 
     
    101101protected: 
    102102    EfcGenericMixerCmd*         m_Slave; 
    103     FireWorks::Device&          m_Parent
     103    FireWorks::Device&          m_ParentDevice
    104104}; 
    105105 
     
    132132    int                         m_bit; 
    133133    EfcGenericMixerCmd*         m_Slave; 
    134     FireWorks::Device&          m_Parent; 
    135 }; 
     134    FireWorks::Device&          m_ParentDevice; 
     135}; 
     136 
     137class SpdifModeControl : public Control::Discrete 
     138
     139 
     140public: 
     141    SpdifModeControl(FireWorks::Device& parent); 
     142    SpdifModeControl(FireWorks::Device& parent, 
     143                    std::string n); 
     144    virtual ~SpdifModeControl(); 
     145 
     146    virtual void show(); 
     147 
     148    virtual bool setValue( const int ); 
     149    virtual int getValue( ); 
     150    virtual bool setValue(int idx, int v) 
     151        {return setValue(v);}; 
     152    virtual int getValue(int idx) 
     153        {return getValue();}; 
     154 
     155    virtual int getMinimum() {return 0;}; 
     156    virtual int getMaximum() {return 0;}; 
     157 
     158protected: 
     159    FireWorks::Device&          m_ParentDevice; 
     160}; 
     161 
    136162 
    137163// for on-off type of controls 
     
    163189    int                         m_bit; 
    164190    EfcGenericIOConfigCmd*      m_Slave; 
    165     FireWorks::Device&          m_Parent; 
     191    FireWorks::Device&          m_ParentDevice; 
     192}; 
     193 
     194 
     195class HwInfoControl : public Control::Discrete 
     196
     197public: 
     198 
     199    enum eHwInfoField { 
     200        eHIF_PhysicalAudioOutCount, 
     201        eHIF_PhysicalAudioInCount, 
     202        eHIF_1394PlaybackCount, 
     203        eHIF_1394RecordCount, 
     204        eHIF_GroupOutCount, 
     205        eHIF_GroupInCount, 
     206        eHIF_PhantomPower, 
     207    }; 
     208public: 
     209    HwInfoControl(FireWorks::Device& parent, 
     210                  enum eHwInfoField); 
     211    HwInfoControl(FireWorks::Device& parent, 
     212                  enum eHwInfoField, std::string n); 
     213    virtual ~HwInfoControl(); 
     214 
     215    virtual void show(); 
     216 
     217    virtual bool setValue( const int ) {return false;}; 
     218    virtual int getValue( ); 
     219    virtual bool setValue(int idx, int v) 
     220        {return setValue(v);}; 
     221    virtual int getValue(int idx) 
     222        {return getValue();}; 
     223 
     224    virtual int getMinimum() {return 0;}; 
     225    virtual int getMaximum() {return 0;}; 
     226 
     227protected: 
     228    FireWorks::Device&          m_ParentDevice; 
     229    enum eHwInfoField           m_Field; 
     230}; 
     231 
     232class MultiControl : public Control::Discrete 
     233
     234public: 
     235 
     236    enum eType { 
     237        eT_SaveSession, 
     238        eT_Identify, 
     239    }; 
     240public: 
     241    MultiControl(FireWorks::Device& parent, enum eType); 
     242    MultiControl(FireWorks::Device& parent, enum eType, 
     243                        std::string n); 
     244    virtual ~MultiControl(); 
     245 
     246    virtual void show(); 
     247 
     248    virtual bool setValue( const int ); 
     249    virtual int getValue( ) {return 0;}; 
     250    virtual bool setValue(int idx, int v) 
     251        {return setValue(v);}; 
     252    virtual int getValue(int idx) 
     253        {return getValue();}; 
     254 
     255    virtual int getMinimum() {return 0;}; 
     256    virtual int getMaximum() {return 0;}; 
     257 
     258protected: 
     259    FireWorks::Device&  m_ParentDevice; 
     260    enum eType          m_Type; 
    166261}; 
    167262 
  • branches/libffado-2.0/src/fireworks/fireworks_device.cpp

    r1280 r1284  
    264264            new BinaryControl(*this, eMT_PlaybackMix, eMC_Mute, ch, 0, node_name.str()+"Mute")); 
    265265        result &= m_MixerContainer->addElement( 
     266            new BinaryControl(*this, eMT_PlaybackMix, eMC_Solo, ch, 0, node_name.str()+"Solo")); 
     267        result &= m_MixerContainer->addElement( 
    266268            new SimpleControl(*this, eMT_PlaybackMix, eMC_Gain, ch, node_name.str()+"Gain")); 
    267269    } 
     
    280282    } 
    281283     
     284    // Physical input mix controls 
     285    for (unsigned int ch=0;ch<m_HwInfo.m_nb_phys_audio_in;ch++) { 
     286        std::ostringstream node_name; 
     287        node_name << "IN" << ch; 
     288         
     289        // result &= m_MixerContainer->addElement( 
     290        //     new BinaryControl(*this, eMT_PhysicalInputMix, eMC_Pad, ch, 0, node_name.str()+"Pad")); 
     291        result &= m_MixerContainer->addElement( 
     292            new BinaryControl(*this, eMT_PhysicalInputMix, eMC_Nominal, ch, 1, node_name.str()+"Nominal")); 
     293    } 
     294 
     295    // add hardware information controls 
     296    m_HwInfoContainer = new Control::Container(this, "HwInfo"); 
     297    result &= m_HwInfoContainer->addElement( 
     298        new HwInfoControl(*this, HwInfoControl::eHIF_PhysicalAudioOutCount, "PhysicalAudioOutCount")); 
     299    result &= m_HwInfoContainer->addElement( 
     300        new HwInfoControl(*this, HwInfoControl::eHIF_PhysicalAudioInCount, "PhysicalAudioInCount")); 
     301    result &= m_HwInfoContainer->addElement( 
     302        new HwInfoControl(*this, HwInfoControl::eHIF_1394PlaybackCount, "1394PlaybackCount")); 
     303    result &= m_HwInfoContainer->addElement( 
     304        new HwInfoControl(*this, HwInfoControl::eHIF_1394RecordCount, "1394RecordCount")); 
     305    result &= m_HwInfoContainer->addElement( 
     306        new HwInfoControl(*this, HwInfoControl::eHIF_GroupOutCount, "GroupOutCount")); 
     307    result &= m_HwInfoContainer->addElement( 
     308        new HwInfoControl(*this, HwInfoControl::eHIF_GroupInCount, "GroupInCount")); 
     309    result &= m_HwInfoContainer->addElement( 
     310        new HwInfoControl(*this, HwInfoControl::eHIF_PhantomPower, "PhantomPower")); 
     311 
     312    // add a save settings control 
     313    result &= this->addElement( 
     314        new MultiControl(*this, MultiControl::eT_SaveSession, "SaveSettings")); 
     315 
     316    // add an identify control 
     317    result &= this->addElement( 
     318        new MultiControl(*this, MultiControl::eT_Identify, "Identify")); 
     319 
     320    // spdif mode control 
     321    result &= this->addElement( 
     322        new SpdifModeControl(*this, "SpdifMode")); 
     323 
    282324    // check for IO config controls and add them if necessary 
    283325    if(m_HwInfo.hasMirroring()) { 
    284         result &= m_MixerContainer->addElement( 
     326        result &= this->addElement( 
    285327            new IOConfigControl(*this, eCR_Mirror, "ChannelMirror")); 
    286328    } 
    287329    if(m_HwInfo.hasSoftwarePhantom()) { 
    288         result &= m_MixerContainer->addElement( 
     330        result &= this->addElement( 
    289331            new IOConfigControl(*this, eCR_Phantom, "PhantomPower")); 
    290332    } 
     
    304346    } 
    305347 
     348    if (!addElement(m_HwInfoContainer)) { 
     349        debugWarning("Could not register hwinfo to device\n"); 
     350        // clean up 
     351        destroyMixer(); 
     352        return false; 
     353    } 
     354 
     355    // load the session block 
     356    if (!loadSession()) { 
     357        debugWarning("Could not load session\n"); 
     358    } 
     359 
    306360    return true; 
    307361} 
     
    314368    if (m_MixerContainer == NULL) { 
    315369        debugOutput(DEBUG_LEVEL_VERBOSE, "no mixer to destroy...\n"); 
    316         return true; 
    317     } 
    318  
    319     if (!deleteElement(m_MixerContainer)) { 
    320         debugError("Mixer present but not registered to the avdevice\n"); 
    321         return false; 
    322     } 
    323  
    324     // remove and delete (as in free) child control elements 
    325     m_MixerContainer->clearElements(true); 
    326     delete m_MixerContainer; 
    327     return true; 
    328 
    329  
     370    } else { 
     371        if (!deleteElement(m_MixerContainer)) { 
     372            debugError("Mixer present but not registered to the avdevice\n"); 
     373            return false; 
     374        } 
     375 
     376        // remove and delete (as in free) child control elements 
     377        m_MixerContainer->clearElements(true); 
     378        delete m_MixerContainer; 
     379        m_MixerContainer = NULL; 
     380    } 
     381 
     382    if (m_HwInfoContainer == NULL) { 
     383        debugOutput(DEBUG_LEVEL_VERBOSE, "no hwinfo to destroy...\n"); 
     384    } else { 
     385        if (!deleteElement(m_HwInfoContainer)) { 
     386            debugError("HwInfo present but not registered to the avdevice\n"); 
     387            return false; 
     388        } 
     389 
     390        // remove and delete (as in free) child control elements 
     391        m_HwInfoContainer->clearElements(true); 
     392        delete m_HwInfoContainer; 
     393        m_HwInfoContainer = NULL; 
     394    } 
     395    return true; 
     396
     397 
     398bool 
     399Device::saveSession() 
     400
     401    // save the session block 
     402//     if ( !updateSession() ) { 
     403//         debugError( "Could not update session\n" ); 
     404//     } else { 
     405        if ( !m_session.saveToDevice(*this) ) { 
     406            debugError( "Could not save session block\n" ); 
     407        } 
     408//     } 
     409 
     410    return true; 
     411
     412 
     413bool 
     414Device::loadSession() 
     415
     416    if ( !m_session.loadFromDevice(*this) ) { 
     417        debugError( "Could not load session block\n" ); 
     418        return false; 
     419    } 
     420    return true; 
     421
    330422 
    331423bool 
  • branches/libffado-2.0/src/fireworks/fireworks_device.h

    r1280 r1284  
    3232#include "efc/efc_cmd.h" 
    3333#include "efc/efc_cmds_hardware.h" 
     34#include "fireworks_session_block.h" 
    3435 
    3536#include <pthread.h> 
     
    4243 
    4344class Device : public GenericAVC::AvDevice { 
     45    friend class MonitorControl; 
     46    friend class SimpleControl; 
     47    friend class BinaryControl; 
     48    friend class IOConfigControl; 
     49     
    4450public: 
    4551    Device( DeviceManager& d, std::auto_ptr<ConfigRom>( configRom ) ); 
     
    110116    uint32_t getSessionBase(); 
    111117 
     118    /** 
     119     * load the session block from the device 
     120     * @return true if successful 
     121     */ 
     122    bool loadSession(); 
     123    /** 
     124     * save the session block to the device 
     125     * @return true if successful 
     126     */ 
     127    bool saveSession(); 
     128 
    112129// Echo specific stuff 
    113130private: 
     
    130147    bool                m_efc_discovery_done; 
    131148 
     149protected: 
     150    Session             m_session; 
    132151private: 
    133152    Control::Container *m_MixerContainer; 
     153    Control::Container *m_HwInfoContainer; 
    134154 
    135155}; 
  • branches/libffado-2.0/src/fireworks/fireworks_session_block.cpp

    r1280 r1284  
    7979        return false; 
    8080    } 
     81 
     82    debugWarning("CRC update not implemented, will fail\n"); 
    8183 
    8284    uint32_t data[len/4]; 
     
    220222 
    221223    return true; 
     224} 
     225 
     226uint32_t 
     227Session::calculateCRC() 
     228{ 
     229    debugWarning("unimplemented\n"); 
     230    return 0; 
    222231} 
    223232 
  • branches/libffado-2.0/src/fireworks/fireworks_session_block.h

    r1280 r1284  
    2121 * 
    2222 */ 
     23 
     24#ifndef FIREWORKS_SESSION_BLOCK_H 
     25#define FIREWORKS_SESSION_BLOCK_H 
    2326 
    2427#include "debugmodule/debugmodule.h" 
     
    124127    void show(); 
    125128 
    126 private: 
     129    uint32_t calculateCRC(); 
     130 
    127131    SessionHeader h; 
    128132    SubSession    s; 
     
    133137 
    134138} // FireWorks 
     139 
     140#endif //FIREWORKS_SESSION_BLOCK_H 
  • branches/libffado-2.0/support/mixer/ffadomixer.in

    r1276 r1284  
    4343from mixer_saffirele import * 
    4444from mixer_saffirepro import * 
    45 from mixer_af2 import * 
     45from mixer_audiofire import * 
    4646from mixer_bcoaudio5 import * 
    4747from mixer_edirolfa66 import * 
     
    6868    [(0x00130e, 0x00000006),'SaffireProMixer'], 
    6969    [(0x00130e, 0x00000000),'SaffireMixer'], 
    70     [(0x001486, 0x00000af2),'AudioFire2Mixer'], 
     70    [(0x001486, 0x00000af2),'AudioFireMixer'], 
     71    [(0x001486, 0x00000af4),'AudioFireMixer'], 
     72    [(0x001486, 0x00000af8),'AudioFireMixer'], 
     73    [(0x001486, 0x0000af12),'AudioFireMixer'], 
    7174    [(0x0007f5, 0x00010049),'BCoAudio5Control'], 
    7275    [(0x0040AB, 0x00010049),'EdirolFa66Control'], 
     
    473476        mixerwidget.configrom = cfgrom 
    474477        mixerwidget.clockselect = ClockSelectInterface(server, basepath+'/DeviceManager/'+path) 
    475         mixerwidget.initValues() 
     478        if 'buildMixer' in dir(mixerwidget): 
     479            mixerwidget.buildMixer() 
     480        if 'initValues' in dir(mixerwidget): 
     481            mixerwidget.initValues() 
    476482        mixerwidgets.append(mixerwidget) 
    477483        mw.addTab( w, mixerapp ) 
  • branches/libffado-2.0/support/mixer/SConscript

    r1276 r1284  
    3434                       'saffireprolarge', 'saffireprosmall', 
    3535                       'saffirelelarge', 'saffirelesmall', 
    36                        'af2', 'bcoaudio5', 'edirolfa66', 
     36                       'audiofire_strip', 'audiofire_settings', 
     37                       'bcoaudio5', 'edirolfa66', 
    3738                       'mackie_generic', 'quatafire', 'motu', 
    3839                       'global', 'dummy' 
     
    4243                       'saffirepro', 
    4344                       'saffirele', 
    44                        'af2', 'bcoaudio5', 'edirolfa66', 
     45                       'audiofire', 
     46                       'bcoaudio5', 'edirolfa66', 
    4547                       'mackie_generic', 'quatafire', 'motu', 
    4648                       'global', 'dummy'