Changeset 1766

Show
Ignore:
Timestamp:
12/28/09 15:07:32 (11 years ago)
Author:
arnonym
Message:

Start some cleanup in the dice-code.

No need for the EAP to be defined inside Dice::Device.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/libffado/src/dice/dice_avdevice.cpp

    r1763 r1766  
    162162    } 
    163163 
    164     bool supports_eap = Device::EAP::supportsEAP(*this); 
     164    bool supports_eap = EAP::supportsEAP(*this); 
    165165    if (supports_eap) { // FIXME: move to buildMixer() ?? 
    166166        m_eap = createEAP(); 
     
    184184} 
    185185 
    186 Device::EAP* 
     186EAP* 
    187187Device::createEAP() { 
    188     return new Device::EAP(*this); 
     188    return new EAP(*this); 
    189189} 
    190190 
     
    15051505} 
    15061506 
    1507 Device::diceNameVector 
     1507diceNameVector 
    15081508Device::getTxNameString(unsigned int i) { 
    15091509    diceNameVector names; 
     
    15251525} 
    15261526 
    1527 Device::diceNameVector 
     1527diceNameVector 
    15281528Device::getRxNameString(unsigned int i) { 
    15291529    diceNameVector names; 
     
    15451545} 
    15461546 
    1547 Device::diceNameVector 
     1547diceNameVector 
    15481548Device::getClockSourceNameString() { 
    15491549    diceNameVector names; 
     
    16031603} 
    16041604 
    1605 Device::diceNameVector 
     1605diceNameVector 
    16061606Device::splitNameString(std::string in) { 
    16071607    diceNameVector names; 
  • trunk/libffado/src/dice/dice_avdevice.h

    r1742 r1766  
    4040#include "libcontrol/CrossbarRouter.h" 
    4141 
    42 #include "dice_eap.h" 
    43  
    4442#include <string> 
    4543#include <vector> 
     
    5452namespace Dice { 
    5553 
    56 class Notifier; 
     54class EAP; 
     55 
     56typedef std::vector< std::string > diceNameVector; 
     57typedef std::vector< std::string >::iterator diceNameVectorIterator; 
     58 
    5759 
    5860class Device : public FFADODevice { 
    5961// private: 
    60     typedef std::vector< std::string > diceNameVector; 
    61     typedef std::vector< std::string >::iterator diceNameVectorIterator; 
    62  
    63 public: 
    64     class Notifier; 
    65     class EAP; 
    66  
    67     /** 
    68      * this class represents the EAP interface 
    69      * available on some devices 
    70      */ 
    71     class EAP : public Control::Container 
    72     { 
    73     public: 
    74         enum eWaitReturn { 
    75             eWR_Error, 
    76             eWR_Timeout, 
    77             eWR_Busy, 
    78             eWR_Done, 
    79         }; 
    80         enum eRegBase { 
    81             eRT_Base, 
    82             eRT_Capability, 
    83             eRT_Command, 
    84             eRT_Mixer, 
    85             eRT_Peak, 
    86             eRT_NewRouting, 
    87             eRT_NewStreamCfg, 
    88             eRT_CurrentCfg, 
    89             eRT_Standalone, 
    90             eRT_Application, 
    91             eRT_None, 
    92         }; 
    93         enum eRouteSource { 
    94             eRS_AES = 0, 
    95             eRS_ADAT = 1, 
    96             eRS_Mixer = 2, 
    97             eRS_InS0 = 4, 
    98             eRS_InS1 = 5, 
    99             eRS_ARM = 10, 
    100             eRS_ARX0 = 11, 
    101             eRS_ARX1 = 12, 
    102             eRS_Muted = 15, 
    103             eRS_Invalid = 16, 
    104         }; 
    105         enum eRouteDestination { 
    106             eRD_AES = 0, 
    107             eRD_ADAT = 1, 
    108             eRD_Mixer0 = 2, 
    109             eRD_Mixer1 = 3, 
    110             eRD_InS0 = 4, 
    111             eRD_InS1 = 5, 
    112             eRD_ARM = 10, 
    113             eRD_ATX0 = 11, 
    114             eRD_ATX1 = 12, 
    115             eRD_Muted = 15, 
    116             eRD_Invalid = 16, 
    117         }; 
    118  
    119     public: 
    120  
    121         // ---------- 
    122         class RouterConfig { 
    123         public: 
    124             struct Route 
    125             { 
    126                 enum eRouteSource src; 
    127                 int srcChannel; 
    128                 enum eRouteDestination dst; 
    129                 int dstChannel; 
    130                 int peak; 
    131             }; 
    132             typedef std::vector<RouterConfig::Route> RouteVector; 
    133             typedef std::vector<RouterConfig::Route>::iterator RouteVectorIterator; 
    134             RouterConfig(EAP &); 
    135             RouterConfig(EAP &, enum eRegBase, unsigned int offset); 
    136             virtual ~RouterConfig(); 
    137  
    138             virtual bool read() {return read(m_base, m_offset);}; 
    139             virtual bool write() {return write(m_base, m_offset);}; 
    140             virtual bool read(enum eRegBase b, unsigned offset); 
    141             virtual bool write(enum eRegBase b, unsigned offset); 
    142             virtual void show(); 
    143  
    144  
    145             bool insertRoute(struct Route r) 
    146                 {return insertRoute(r, m_routes.size());}; 
    147             bool insertRoute(struct Route r, unsigned int index); 
    148             bool replaceRoute(unsigned int old_index, struct Route new_route); 
    149             bool replaceRoute(struct Route old_route, struct Route new_route); 
    150             bool removeRoute(struct Route r); 
    151             bool removeRoute(unsigned int index); 
    152             int getRouteIndex(struct Route r); 
    153             struct Route getRoute(unsigned int index); 
    154  
    155             unsigned int getNbRoutes() {return m_routes.size();}; 
    156  
    157             struct Route getRouteForDestination(enum eRouteDestination dst, int channel); 
    158             RouteVector getRoutesForSource(enum eRouteSource src, int channel); 
    159  
    160             struct Route decodeRoute(uint32_t val); 
    161             uint32_t encodeRoute(struct Route r); 
    162         public: 
    163             static enum eRouteDestination intToRouteDestination(int); 
    164             static enum eRouteSource intToRouteSource(int); 
    165         protected: 
    166             EAP &m_eap; 
    167             enum eRegBase m_base; 
    168             unsigned int m_offset; 
    169             RouteVector m_routes; 
    170         protected: 
    171             DECLARE_DEBUG_MODULE_REFERENCE; 
    172         }; 
    173  
    174         // ---------- 
    175         // the peak space is a special version of a router config 
    176         class PeakSpace : public RouterConfig { 
    177         public: 
    178             PeakSpace(EAP &p) : RouterConfig(p, eRT_Peak, 0) {}; 
    179             virtual ~PeakSpace() {}; 
    180  
    181             virtual bool read() {return read(m_base, m_offset);}; 
    182             virtual bool write() {return write(m_base, m_offset);}; 
    183             virtual bool read(enum eRegBase b, unsigned offset); 
    184             virtual bool write(enum eRegBase b, unsigned offset); 
    185             virtual void show(); 
    186         }; 
    187  
    188         // ---------- 
    189         class StreamConfig { 
    190         public: 
    191             struct ConfigBlock { // FIXME: somewhere in the DICE avdevice this is present too 
    192                 uint32_t nb_audio; 
    193                 uint32_t nb_midi; 
    194                 uint32_t names[DICE_EAP_CHANNEL_CONFIG_NAMESTR_LEN_QUADS]; 
    195                 uint32_t ac3_map; 
    196             }; 
    197             void showConfigBlock(struct ConfigBlock &); 
    198             diceNameVector getNamesForBlock(struct ConfigBlock &b); 
    199         public: 
    200             StreamConfig(EAP &, enum eRegBase, unsigned int offset); 
    201             ~StreamConfig(); 
    202  
    203             bool read() {return read(m_base, m_offset);}; 
    204             bool write() {return write(m_base, m_offset);}; 
    205             bool read(enum eRegBase b, unsigned offset); 
    206             bool write(enum eRegBase b, unsigned offset); 
    207  
    208             void show(); 
    209  
    210         private: 
    211             EAP &m_eap; 
    212             enum eRegBase m_base; 
    213             unsigned int m_offset; 
    214  
    215             uint32_t m_nb_tx; 
    216             uint32_t m_nb_rx; 
    217  
    218             struct ConfigBlock *m_tx_configs; 
    219             struct ConfigBlock *m_rx_configs; 
    220  
    221             DECLARE_DEBUG_MODULE_REFERENCE; 
    222         }; 
    223  
    224     public: // mixer control subclass 
    225         class Mixer : public Control::MatrixMixer { 
    226         public: 
    227             Mixer(EAP &); 
    228             ~Mixer(); 
    229  
    230             bool init(); 
    231             void show(); 
    232  
    233             void updateNameCache(); 
    234             /** 
    235              * load the coefficients from the device into the local cache 
    236              * @return  
    237              */ 
    238             bool loadCoefficients(); 
    239             /** 
    240              * Stores the coefficients from the cache to the device 
    241              * @return  
    242              */ 
    243             bool storeCoefficients(); 
    244  
    245             virtual int getRowCount( ); 
    246             virtual int getColCount( ); 
    247  
    248             virtual int canWrite( const int, const int ); 
    249             virtual double setValue( const int, const int, const double ); 
    250             virtual double getValue( const int, const int ); 
    251  
    252             bool hasNames() const { return false; } 
    253  
    254             // TODO: implement connections. 
    255             bool canConnect() const { return false; } 
    256  
    257             // full map updates are unsupported 
    258             virtual bool getCoefficientMap(int &); 
    259             virtual bool storeCoefficientMap(int &); 
    260  
    261         private: 
    262             EAP &         m_eap; 
    263             fb_quadlet_t *m_coeff; 
    264  
    265             std::map<int, RouterConfig::Route> m_input_route_map; 
    266             std::map<int, RouterConfig::RouteVector> m_output_route_map; 
    267  
    268             DECLARE_DEBUG_MODULE_REFERENCE; 
    269         }; 
    270  
    271         // ---------- 
    272         class Router : public Control::CrossbarRouter { 
    273         private: 
    274             struct Source { 
    275                 std::string name; 
    276                 enum eRouteSource src; 
    277                 int srcChannel; 
    278             }; 
    279             typedef std::vector<Source> SourceVector; 
    280             typedef std::vector<Source>::iterator SourceVectorIterator; 
    281  
    282             struct Destination { 
    283                 std::string name; 
    284                 enum eRouteDestination dst; 
    285                 int dstChannel; 
    286             }; 
    287             typedef std::vector<Destination> DestinationVector; 
    288             typedef std::vector<Destination>::iterator DestinationVectorIterator; 
    289  
    290         public: 
    291             Router(EAP &); 
    292             ~Router(); 
    293  
    294             void show(); 
    295  
    296             // to be subclassed by the implementing 
    297             // devices 
    298             virtual void setupSources(); 
    299             virtual void setupDestinations(); 
    300  
    301             void setupDestinationsAddDestination(const char *name, enum eRouteDestination dstid, 
    302                                                  unsigned int base, unsigned int cnt); 
    303             void setupSourcesAddSource(const char *name, enum eRouteSource srcid, 
    304                                        unsigned int base, unsigned int cnt); 
    305  
    306             int getDestinationIndex(enum eRouteDestination dstid, int channel); 
    307             int getSourceIndex(enum eRouteSource srcid, int channel); 
    308  
    309             // per-coefficient access 
    310             virtual std::string getSourceName(const int); 
    311             virtual std::string getDestinationName(const int); 
    312             virtual int getSourceIndex(std::string); 
    313             virtual int getDestinationIndex(std::string); 
    314             virtual NameVector getSourceNames(); 
    315             virtual NameVector getDestinationNames(); 
    316  
    317             virtual Control::CrossbarRouter::Groups getSources(); 
    318             virtual Control::CrossbarRouter::Groups getDestinations(); 
    319  
    320             virtual IntVector getDestinationsForSource(const int); 
    321             virtual int getSourceForDestination(const int); 
    322  
    323             virtual bool canConnect( const int source, const int dest); 
    324             virtual bool setConnectionState( const int source, const int dest, const bool enable); 
    325             virtual bool getConnectionState( const int source, const int dest ); 
    326  
    327             virtual bool canConnect(std::string, std::string); 
    328             virtual bool setConnectionState(std::string, std::string, const bool enable); 
    329             virtual bool getConnectionState(std::string, std::string); 
    330  
    331             virtual bool clearAllConnections(); 
    332  
    333             virtual int getNbSources(); 
    334             virtual int getNbDestinations(); 
    335  
    336             // functions to access the entire routing map at once 
    337             // idea is that the row/col nodes that are 1 get a routing entry 
    338             virtual bool getConnectionMap(int *); 
    339             virtual bool setConnectionMap(int *); 
    340  
    341             // peak metering support 
    342             virtual bool hasPeakMetering(); 
    343             virtual bool getPeakValues(double &) {return false;}; 
    344             virtual double getPeakValue(const int source, const int dest); 
    345             virtual Control::CrossbarRouter::PeakValues getPeakValues(); 
    346  
    347         private: 
    348             EAP &m_eap; 
    349             // these contain the sources and destinations available for this 
    350             // router 
    351             SourceVector      m_sources; 
    352             DestinationVector m_destinations; 
    353  
    354             PeakSpace &m_peak; 
    355  
    356             DECLARE_DEBUG_MODULE_REFERENCE; 
    357         }; 
    358  
    359     public: 
    360         EAP(Device &); 
    361         virtual ~EAP(); 
    362  
    363         static bool supportsEAP(Device &); 
    364         bool init(); 
    365  
    366         void show(); 
    367         void showApplication(); 
    368         enum eWaitReturn operationBusy(); 
    369         enum eWaitReturn waitForOperationEnd(int max_wait_time_ms = 100); 
    370  
    371         bool updateConfigurationCache(); 
    372         RouterConfig * getActiveRouterConfig(); 
    373         StreamConfig * getActiveStreamConfig(); 
    374  
    375         bool updateRouterConfig(RouterConfig&, bool low, bool mid, bool high); 
    376         bool updateCurrentRouterConfig(RouterConfig&); 
    377         bool updateStreamConfig(StreamConfig&, bool low, bool mid, bool high); 
    378         bool updateStreamConfig(RouterConfig&, StreamConfig&, bool low, bool mid, bool high); 
    379  
    380         bool loadFlashConfig(); 
    381         bool storeFlashConfig(); 
    382  
    383     private: 
    384         bool loadRouterConfig(bool low, bool mid, bool high); 
    385         bool loadStreamConfig(bool low, bool mid, bool high); 
    386         bool loadRouterAndStreamConfig(bool low, bool mid, bool high); 
    387     private: 
    388         bool     m_router_exposed; 
    389         bool     m_router_readonly; 
    390         bool     m_router_flashstored; 
    391         uint16_t m_router_nb_entries; 
    392  
    393         bool     m_mixer_exposed; 
    394         bool     m_mixer_readonly; 
    395         bool     m_mixer_flashstored; 
    396         uint8_t  m_mixer_tx_id; 
    397         uint8_t  m_mixer_rx_id; 
    398         uint8_t  m_mixer_nb_tx; 
    399         uint8_t  m_mixer_nb_rx; 
    400  
    401         bool     m_general_support_dynstream; 
    402         bool     m_general_support_flash; 
    403         bool     m_general_peak_enabled; 
    404         uint8_t  m_general_max_tx; 
    405         uint8_t  m_general_max_rx; 
    406         bool     m_general_stream_cfg_stored; 
    407         uint16_t m_general_chip; 
    408  
    409         bool commandHelper(fb_quadlet_t cmd); 
    410  
    411     public: 
    412         bool readReg(enum eRegBase, unsigned offset, quadlet_t *); 
    413         bool writeReg(enum eRegBase, unsigned offset, quadlet_t); 
    414         bool readRegBlock(enum eRegBase, unsigned, fb_quadlet_t *, size_t); 
    415         bool writeRegBlock(enum eRegBase, unsigned, fb_quadlet_t *, size_t); 
    416         bool readRegBlockSwapped(enum eRegBase, unsigned, fb_quadlet_t *, size_t); 
    417         bool writeRegBlockSwapped(enum eRegBase, unsigned, fb_quadlet_t *, size_t); 
    418         fb_nodeaddr_t offsetGen(enum eRegBase, unsigned, size_t); 
    419  
    420     protected: 
    421         DECLARE_DEBUG_MODULE_REFERENCE; 
    422  
    423     private: 
    424         Device & m_device; 
    425         Mixer*   m_mixer; 
    426         Router*  m_router; 
    427         RouterConfig m_current_cfg_routing_low; 
    428         RouterConfig m_current_cfg_routing_mid; 
    429         RouterConfig m_current_cfg_routing_high; 
    430         StreamConfig m_current_cfg_stream_low; 
    431         StreamConfig m_current_cfg_stream_mid; 
    432         StreamConfig m_current_cfg_stream_high; 
    433     public: 
    434         Mixer*  getMixer() {return m_mixer;}; 
    435         Router* getRouter() {return m_router;}; 
    436  
    437     private: 
    438  
    439         fb_quadlet_t m_capability_offset; 
    440         fb_quadlet_t m_capability_size; 
    441         fb_quadlet_t m_cmd_offset; 
    442         fb_quadlet_t m_cmd_size; 
    443         fb_quadlet_t m_mixer_offset; 
    444         fb_quadlet_t m_mixer_size; 
    445         fb_quadlet_t m_peak_offset; 
    446         fb_quadlet_t m_peak_size; 
    447         fb_quadlet_t m_new_routing_offset; 
    448         fb_quadlet_t m_new_routing_size; 
    449         fb_quadlet_t m_new_stream_cfg_offset; 
    450         fb_quadlet_t m_new_stream_cfg_size; 
    451         fb_quadlet_t m_curr_cfg_offset; 
    452         fb_quadlet_t m_curr_cfg_size; 
    453         fb_quadlet_t m_standalone_offset; 
    454         fb_quadlet_t m_standalone_size; 
    455         fb_quadlet_t m_app_offset; 
    456         fb_quadlet_t m_app_size; 
    457     }; 
     62    friend class EAP; 
    45863 
    45964public: 
     
    602207// private: 
    603208public: 
    604     // notification 
    605     Notifier *m_notifier; 
    606  
    607209    /** 
    608210     * this class reacts on the DICE device writing to the 
     
    621223    }; 
    622224 
     225    // notification 
     226    Notifier *m_notifier; 
     227 
    623228 
    624229 
     
    626231 
    627232} 
     233// vim: et 
    628234#endif 
  • trunk/libffado/src/dice/dice_eap.cpp

    r1763 r1766  
    7070} 
    7171 
    72  
    73 Device::EAP::EAP(Device &d) 
     72IMPL_DEBUG_MODULE( EAP, EAP, DEBUG_LEVEL_NORMAL ); 
     73 
     74EAP::EAP(Device &d) 
    7475: Control::Container(&d, "EAP") 
    75 , m_debugModule(d.m_debugModule) // NOTE: has to be initialized before creating the config classes 
    76                                  //       otherwise the reference content used by those is bogus 
    7776, m_device(d) 
    7877, m_mixer( NULL ) 
     
    8786} 
    8887 
    89 Device::EAP::~EAP() 
     88EAP::~EAP() 
    9089{ 
    9190    // remove all control elements registered to this device (w/o free) 
     
    107106 
    108107bool 
    109 Device::EAP::init() { 
     108EAP::init() { 
    110109    if(!supportsEAP(m_device)) { 
    111110        debugError("Device does not support EAP"); 
     
    210209 
    211210bool 
    212 Device::EAP::updateConfigurationCache() 
     211EAP::updateConfigurationCache() 
    213212{ 
    214213    if(!m_current_cfg_routing_low.read()) { 
     
    244243 * @return  
    245244 */ 
    246 Device::EAP::RouterConfig * 
    247 Device::EAP::getActiveRouterConfig() 
     245EAP::RouterConfig * 
     246EAP::getActiveRouterConfig() 
    248247{ 
    249248    switch(m_device.getCurrentConfig()) { 
    250         case eDC_Low: return &m_current_cfg_routing_low; 
    251         case eDC_Mid: return &m_current_cfg_routing_mid; 
    252         case eDC_High: return &m_current_cfg_routing_high; 
     249        case Device::eDC_Low: return &m_current_cfg_routing_low; 
     250        case Device::eDC_Mid: return &m_current_cfg_routing_mid; 
     251        case Device::eDC_High: return &m_current_cfg_routing_high; 
    253252        default: 
    254253            debugError("Unsupported configuration mode\n"); 
     
    261260 * @return  
    262261 */ 
    263 Device::EAP::StreamConfig * 
    264 Device::EAP::getActiveStreamConfig() 
     262EAP::StreamConfig * 
     263EAP::getActiveStreamConfig() 
    265264{ 
    266265    switch(m_device.getCurrentConfig()) { 
    267         case eDC_Low: return &m_current_cfg_stream_low; 
    268         case eDC_Mid: return &m_current_cfg_stream_mid; 
    269         case eDC_High: return &m_current_cfg_stream_high; 
     266        case Device::eDC_Low: return &m_current_cfg_stream_low; 
     267        case Device::eDC_Mid: return &m_current_cfg_stream_mid; 
     268        case Device::eDC_High: return &m_current_cfg_stream_high; 
    270269        default: 
    271270            debugError("Unsupported configuration mode\n"); 
     
    283282 */ 
    284283bool 
    285 Device::EAP::updateRouterConfig(RouterConfig& rcfg, bool low, bool mid, bool high) { 
     284EAP::updateRouterConfig(RouterConfig& rcfg, bool low, bool mid, bool high) { 
    286285    // write the router config to the appropriate memory space on the device 
    287286    if(!rcfg.write(eRT_NewRouting, 0)) { 
     
    305304 */ 
    306305bool 
    307 Device::EAP::updateCurrentRouterConfig(RouterConfig& rcfg) { 
     306EAP::updateCurrentRouterConfig(RouterConfig& rcfg) { 
    308307    switch(m_device.getCurrentConfig()) { 
    309         case eDC_Low: return updateRouterConfig(rcfg, true, false, false); 
    310         case eDC_Mid: return updateRouterConfig(rcfg, false, true, false); 
    311         case eDC_High: return updateRouterConfig(rcfg, false, false, true); 
     308        case Device::eDC_Low: return updateRouterConfig(rcfg, true, false, false); 
     309        case Device::eDC_Mid: return updateRouterConfig(rcfg, false, true, false); 
     310        case Device::eDC_High: return updateRouterConfig(rcfg, false, false, true); 
    312311        default: 
    313312            debugError("Unsupported configuration mode\n"); 
     
    325324 */ 
    326325bool 
    327 Device::EAP::updateStreamConfig(StreamConfig& scfg, bool low, bool mid, bool high) { 
     326EAP::updateStreamConfig(StreamConfig& scfg, bool low, bool mid, bool high) { 
    328327    // write the stream config to the appropriate memory space on the device 
    329328    if(!scfg.write(eRT_NewStreamCfg, 0)) { 
     
    350349 */ 
    351350bool 
    352 Device::EAP::updateStreamConfig(RouterConfig& rcfg, StreamConfig& scfg, bool low, bool mid, bool high) { 
     351EAP::updateStreamConfig(RouterConfig& rcfg, StreamConfig& scfg, bool low, bool mid, bool high) { 
    353352    // write the router config to the appropriate memory space on the device 
    354353    if(!rcfg.write(eRT_NewRouting, 0)) { 
     
    372371 
    373372bool 
    374 Device::EAP::loadFlashConfig() { 
     373EAP::loadFlashConfig() { 
    375374    bool retval = true; 
    376375    debugWarning("Untested code\n"); 
     
    386385 
    387386bool 
    388 Device::EAP::storeFlashConfig() { 
     387EAP::storeFlashConfig() { 
    389388    //debugWarning("Untested code\n") // Works. -Arnold; 
    390389    fb_quadlet_t cmd = DICE_EAP_CMD_OPCODE_ST_FLASH_CFG; 
     
    395394// helpers 
    396395void 
    397 Device::EAP::show() 
     396EAP::show() 
    398397{ 
    399398    printMessage("== DICE EAP ==\n"); 
     
    472471} 
    473472void 
    474 Device::EAP::showApplication() 
     473EAP::showApplication() 
    475474{ 
    476475    printMessage("--- Application space ---\n"); 
     
    491490// EAP load/store operations 
    492491 
    493 enum Device::EAP::eWaitReturn 
    494 Device::EAP::operationBusy() { 
     492enum EAP::eWaitReturn 
     493EAP::operationBusy() { 
    495494    fb_quadlet_t tmp; 
    496495    if(!readReg(eRT_Command, DICE_EAP_COMMAND_OPCODE, &tmp)) { 
     
    505504} 
    506505 
    507 enum Device::EAP::eWaitReturn 
    508 Device::EAP::waitForOperationEnd(int max_wait_time_ms) { 
     506enum EAP::eWaitReturn 
     507EAP::waitForOperationEnd(int max_wait_time_ms) { 
    509508    int max_waits = max_wait_time_ms; 
    510509 
     
    526525 
    527526bool 
    528 Device::EAP::commandHelper(fb_quadlet_t cmd) { 
     527EAP::commandHelper(fb_quadlet_t cmd) { 
    529528    // check whether another command is still running 
    530529    if(operationBusy() == eWR_Busy) { 
     
    568567 
    569568bool 
    570 Device::EAP::loadRouterConfig(bool low, bool mid, bool high) { 
     569EAP::loadRouterConfig(bool low, bool mid, bool high) { 
    571570    fb_quadlet_t cmd = DICE_EAP_CMD_OPCODE_LD_ROUTER; 
    572571    if(low) cmd |= DICE_EAP_CMD_OPCODE_FLAG_LD_LOW; 
     
    578577 
    579578bool 
    580 Device::EAP::loadStreamConfig(bool low, bool mid, bool high) { 
     579EAP::loadStreamConfig(bool low, bool mid, bool high) { 
    581580    debugWarning("Untested code\n"); 
    582581    fb_quadlet_t cmd = DICE_EAP_CMD_OPCODE_LD_STRM_CFG; 
     
    589588 
    590589bool 
    591 Device::EAP::loadRouterAndStreamConfig(bool low, bool mid, bool high) { 
     590EAP::loadRouterAndStreamConfig(bool low, bool mid, bool high) { 
    592591    debugWarning("Untested code\n"); 
    593592    fb_quadlet_t cmd = DICE_EAP_CMD_OPCODE_LD_RTR_STRM_CFG; 
     
    601600// internal I/O operations 
    602601bool 
    603 Device::EAP::readReg(enum eRegBase base, unsigned offset, fb_quadlet_t *result) { 
     602EAP::readReg(enum eRegBase base, unsigned offset, fb_quadlet_t *result) { 
    604603    fb_nodeaddr_t addr = offsetGen(base, offset, 4); 
    605604    return m_device.readReg(addr, result); 
     
    607606 
    608607bool 
    609 Device::EAP::writeReg(enum eRegBase base, unsigned offset, fb_quadlet_t data) { 
     608EAP::writeReg(enum eRegBase base, unsigned offset, fb_quadlet_t data) { 
    610609    fb_nodeaddr_t addr = offsetGen(base, offset, 4); 
    611610    return m_device.writeReg(addr, data); 
     
    613612 
    614613bool 
    615 Device::EAP::readRegBlock(enum eRegBase base, unsigned offset, fb_quadlet_t *data, size_t length) { 
     614EAP::readRegBlock(enum eRegBase base, unsigned offset, fb_quadlet_t *data, size_t length) { 
    616615    fb_nodeaddr_t addr = offsetGen(base, offset, length); 
    617616    return m_device.readRegBlock(addr, data, length); 
     
    619618 
    620619bool 
    621 Device::EAP::writeRegBlock(enum eRegBase base, unsigned offset, fb_quadlet_t *data, size_t length) { 
     620EAP::writeRegBlock(enum eRegBase base, unsigned offset, fb_quadlet_t *data, size_t length) { 
    622621    fb_nodeaddr_t addr = offsetGen(base, offset, length); 
    623622    return m_device.writeRegBlock(addr, data, length); 
     
    625624 
    626625fb_nodeaddr_t 
    627 Device::EAP::offsetGen(enum eRegBase base, unsigned offset, size_t length) { 
     626EAP::offsetGen(enum eRegBase base, unsigned offset, size_t length) { 
    628627    fb_nodeaddr_t addr; 
    629628    fb_nodeaddr_t maxlen; 
     
    688687 */ 
    689688bool 
    690 Device::EAP::supportsEAP(Device &d) 
     689EAP::supportsEAP(Device &d) 
    691690{ 
    692691    DebugModule &m_debugModule = d.m_debugModule; 
     
    708707 
    709708// ----------- Mixer ------------- 
    710 Device::EAP::Mixer::Mixer(EAP &p) 
     709EAP::Mixer::Mixer(EAP &p) 
    711710: Control::MatrixMixer(&p.m_device, "MatrixMixer") 
    712711, m_eap(p) 
     
    716715} 
    717716 
    718 Device::EAP::Mixer::~Mixer() 
     717EAP::Mixer::~Mixer() 
    719718{ 
    720719    if (m_coeff) { 
     
    725724 
    726725bool 
    727 Device::EAP::Mixer::init() 
     726EAP::Mixer::init() 
    728727{ 
    729728    if(!m_eap.m_mixer_exposed) { 
     
    754753 
    755754bool 
    756 Device::EAP::Mixer::loadCoefficients() 
     755EAP::Mixer::loadCoefficients() 
    757756{ 
    758757    if(m_coeff == NULL) { 
     
    770769 
    771770bool 
    772 Device::EAP::Mixer::storeCoefficients() 
     771EAP::Mixer::storeCoefficients() 
    773772{ 
    774773    if(m_coeff == NULL) { 
     
    790789 
    791790void 
    792 Device::EAP::Mixer::updateNameCache() 
     791EAP::Mixer::updateNameCache() 
    793792{ 
    794793    // figure out the number of i/o's 
     
    873872 
    874873void 
    875 Device::EAP::Mixer::show() 
     874EAP::Mixer::show() 
    876875{ 
    877876    int nb_inputs = m_eap.m_mixer_nb_tx; 
     
    927926 
    928927int 
    929 Device::EAP::Mixer::canWrite( const int row, const int col) 
     928EAP::Mixer::canWrite( const int row, const int col) 
    930929{ 
    931930    if(m_eap.m_mixer_readonly) { 
     
    936935 
    937936double 
    938 Device::EAP::Mixer::setValue( const int row, const int col, const double val) 
     937EAP::Mixer::setValue( const int row, const int col, const double val) 
    939938{ 
    940939    if(m_eap.m_mixer_readonly) { 
     
    953952 
    954953double 
    955 Device::EAP::Mixer::getValue( const int row, const int col) 
     954EAP::Mixer::getValue( const int row, const int col) 
    956955{ 
    957956    int nb_inputs = m_eap.m_mixer_nb_tx; 
     
    966965 
    967966int 
    968 Device::EAP::Mixer::getRowCount() 
     967EAP::Mixer::getRowCount() 
    969968{ 
    970969    return m_eap.m_mixer_nb_tx; 
     
    972971 
    973972int 
    974 Device::EAP::Mixer::getColCount() 
     973EAP::Mixer::getColCount() 
    975974{ 
    976975    return m_eap.m_mixer_nb_rx; 
     
    979978// full map updates are unsupported 
    980979bool 
    981 Device::EAP::Mixer::getCoefficientMap(int &) { 
     980EAP::Mixer::getCoefficientMap(int &) { 
    982981    return false; 
    983982} 
    984983 
    985984bool 
    986 Device::EAP::Mixer::storeCoefficientMap(int &) { 
     985EAP::Mixer::storeCoefficientMap(int &) { 
    987986    if(m_eap.m_mixer_readonly) { 
    988987        debugWarning("Mixer is read-only\n"); 
     
    990989    } 
    991990    return false; 
     991} 
     992 
     993// Names 
     994std::string 
     995EAP::Mixer::getColName(const int col) { 
     996    //debugOutput(DEBUG_LEVEL_VERBOSE, "EAP::Mixer::getColName( %i )\n"); 
     997    char tmp[32]; 
     998    snprintf(tmp, 32, "%s:%d", srcBlockToString(m_input_route_map[col].src), m_input_route_map[col].srcChannel); 
     999    return tmp; 
     1000} 
     1001std::string 
     1002EAP::Mixer::getRowName(const int row) { 
     1003    if (m_output_route_map[row].size() == 0) { 
     1004        return "Not connected"; 
     1005    } 
     1006    if (m_output_route_map[row].size() > 1) { 
     1007        return "Many"; 
     1008    } 
     1009    char tmp[32]; 
     1010    snprintf(tmp, 32, "%s:%d", dstBlockToString(m_output_route_map[row][0].dst), m_output_route_map[row][0].dstChannel); 
     1011    return tmp; 
    9921012} 
    9931013 
     
    9971017 
    9981018 
    999 Device::EAP::Router::Router(EAP &p) 
     1019EAP::Router::Router(EAP &p) 
    10001020: Control::CrossbarRouter(&p.m_device, "Router") 
    10011021, m_eap(p) 
     
    10071027} 
    10081028 
    1009 Device::EAP::Router::~Router() 
     1029EAP::Router::~Router() 
    10101030{ 
    10111031    delete &m_peak; 
     
    10131033 
    10141034void 
    1015 Device::EAP::Router::setupSourcesAddSource(const char *basename, enum eRouteSource srcid,  
     1035EAP::Router::setupSourcesAddSource(const char *basename, enum eRouteSource srcid,  
    10161036                                           unsigned int base, unsigned int cnt) 
    10171037{ 
     
    10261046 
    10271047void 
    1028 Device::EAP::Router::setupDestinationsAddDestination(const char *basename, enum eRouteDestination dstid, 
     1048EAP::Router::setupDestinationsAddDestination(const char *basename, enum eRouteDestination dstid, 
    10291049                                                     unsigned int base, unsigned int cnt) 
    10301050{ 
     
    10401060 
    10411061void 
    1042 Device::EAP::Router::setupSources() { 
     1062EAP::Router::setupSources() { 
    10431063    // add the routing sources and destinations for a DICE chip 
    10441064    switch(m_eap.m_general_chip) { 
     
    10851105 
    10861106void 
    1087 Device::EAP::Router::setupDestinations() { 
     1107EAP::Router::setupDestinations() { 
    10881108    // add the routing sources and destinations for a DICE chip 
    10891109    switch(m_eap.m_general_chip) { 
     
    11311151 
    11321152std::string 
    1133 Device::EAP::Router::getSourceName(const int srcid) 
     1153EAP::Router::getSourceName(const int srcid) 
    11341154{ 
    11351155    if((unsigned)srcid < m_sources.size()) { 
     
    11421162 
    11431163std::string 
    1144 Device::EAP::Router::getDestinationName(const int dstid) 
     1164EAP::Router::getDestinationName(const int dstid) 
    11451165{ 
    11461166    if((unsigned)dstid < m_destinations.size()) { 
     
    11531173 
    11541174int 
    1155 Device::EAP::Router::getSourceIndex(std::string name) 
     1175EAP::Router::getSourceIndex(std::string name) 
    11561176{ 
    11571177    int i = 0; 
     
    11671187 
    11681188int 
    1169 Device::EAP::Router::getDestinationIndex(std::string name) 
     1189EAP::Router::getDestinationIndex(std::string name) 
    11701190{ 
    11711191    int i = 0; 
     
    11811201 
    11821202int 
    1183 Device::EAP::Router::getSourceIndex(enum eRouteSource srcid, int channel) 
     1203EAP::Router::getSourceIndex(enum eRouteSource srcid, int channel) 
    11841204{ 
    11851205    int i = 0; 
     
    11951215 
    11961216int 
    1197 Device::EAP::Router::getDestinationIndex(enum eRouteDestination dstid, int channel) 
     1217EAP::Router::getDestinationIndex(enum eRouteDestination dstid, int channel) 
    11981218{ 
    11991219    int i = 0; 
     
    12091229 
    12101230Control::CrossbarRouter::NameVector 
    1211 Device::EAP::Router::getSourceNames() 
     1231EAP::Router::getSourceNames() 
    12121232{ 
    12131233    Control::CrossbarRouter::NameVector n; 
     
    12221242 
    12231243Control::CrossbarRouter::NameVector 
    1224 Device::EAP::Router::getDestinationNames() 
     1244EAP::Router::getDestinationNames() 
    12251245{ 
    12261246    Control::CrossbarRouter::NameVector n; 
     
    12351255 
    12361256Control::CrossbarRouter::Groups 
    1237 Device::EAP::Router::getSources() 
    1238 { 
    1239     debugError("Device::EAP::Router::getSources() is not yet implemented!"); 
     1257EAP::Router::getSources() 
     1258{ 
     1259    debugError("EAP::Router::getSources() is not yet implemented!"); 
    12401260    return Control::CrossbarRouter::Groups(); 
    12411261} 
    12421262 
    12431263Control::CrossbarRouter::Groups 
    1244 Device::EAP::Router::getDestinations() 
    1245 { 
    1246     debugError("Device::EAP::Router::getDestinations() is not yet implemented!"); 
     1264EAP::Router::getDestinations() 
     1265{ 
     1266    debugError("EAP::Router::getDestinations() is not yet implemented!"); 
    12471267    return Control::CrossbarRouter::Groups(); 
    12481268} 
    12491269 
    12501270Control::CrossbarRouter::IntVector 
    1251 Device::EAP::Router::getDestinationsForSource(const int srcid) 
     1271EAP::Router::getDestinationsForSource(const int srcid) 
    12521272{ 
    12531273    IntVector retval; 
     
    12911311 
    12921312int 
    1293 Device::EAP::Router::getSourceForDestination(const int dstid) 
     1313EAP::Router::getSourceForDestination(const int dstid) 
    12941314{ 
    12951315    if((unsigned)dstid < m_destinations.size()) { 
     
    13261346 
    13271347int 
    1328 Device::EAP::Router::getNbSources() 
     1348EAP::Router::getNbSources() 
    13291349{ 
    13301350    return m_sources.size(); 
     
    13321352 
    13331353int 
    1334 Device::EAP::Router::getNbDestinations() 
     1354EAP::Router::getNbDestinations() 
    13351355{ 
    13361356    return m_destinations.size(); 
     
    13381358 
    13391359bool 
    1340 Device::EAP::Router::canConnect(const int source, const int dest) 
     1360EAP::Router::canConnect(const int source, const int dest) 
    13411361{ 
    13421362    if((unsigned)source >= m_sources.size()) { 
     
    13581378 
    13591379bool 
    1360 Device::EAP::Router::setConnectionState(const int source, const int dest, const bool enable) 
     1380EAP::Router::setConnectionState(const int source, const int dest, const bool enable) 
    13611381{ 
    13621382    if((unsigned)source >= m_sources.size()) { 
     
    13801400 
    13811401    // build a new routing configuration 
    1382     RouterConfig newcfg = Device::EAP::RouterConfig(*rcfg); 
     1402    RouterConfig newcfg = EAP::RouterConfig(*rcfg); 
    13831403 
    13841404    // construct the routing entry to find 
     
    13951415        if(enable) { 
    13961416            debugOutput(DEBUG_LEVEL_VERBOSE, "connection %d => %d already present\n", source, dest); 
    1397             return true; 
     1417            //return true; 
    13981418        } else { 
    13991419            // remove the route 
     
    14121432 
    14131433bool 
    1414 Device::EAP::Router::getConnectionState(const int source, const int dest) 
     1434EAP::Router::getConnectionState(const int source, const int dest) 
    14151435{ 
    14161436    if((unsigned)source >= m_sources.size()) { 
     
    14341454 
    14351455    // build a new routing configuration 
    1436     RouterConfig newcfg = Device::EAP::RouterConfig(*rcfg); 
     1456    RouterConfig newcfg = EAP::RouterConfig(*rcfg); 
    14371457 
    14381458    // construct the routing entry to find 
     
    14521472 
    14531473bool 
    1454 Device::EAP::Router::canConnect(std::string src, std::string dst) 
     1474EAP::Router::canConnect(std::string src, std::string dst) 
    14551475{ 
    14561476    int srcidx = getSourceIndex(src); 
     
    14601480 
    14611481bool 
    1462 Device::EAP::Router::setConnectionState(std::string src, std::string dst, const bool enable) 
     1482EAP::Router::setConnectionState(std::string src, std::string dst, const bool enable) 
    14631483{ 
    14641484    int srcidx = getSourceIndex(src); 
     
    14681488 
    14691489bool 
    1470 Device::EAP::Router::getConnectionState(std::string src, std::string dst) 
     1490EAP::Router::getConnectionState(std::string src, std::string dst) 
    14711491{ 
    14721492    int srcidx = getSourceIndex(src); 
     
    14821502// allocated by the user 
    14831503bool 
    1484 Device::EAP::Router::getConnectionMap(int *map) 
     1504EAP::Router::getConnectionMap(int *map) 
    14851505{ 
    14861506    unsigned int nb_sources = getNbSources(); 
     
    15181538 
    15191539bool 
    1520 Device::EAP::Router::setConnectionMap(int *map) 
     1540EAP::Router::setConnectionMap(int *map) 
    15211541{ 
    15221542    return false; 
     
    15241544 
    15251545bool 
    1526 Device::EAP::Router::clearAllConnections() 
     1546EAP::Router::clearAllConnections() 
    15271547{ 
    15281548    // build a new empty routing configuration 
    1529     RouterConfig newcfg = Device::EAP::RouterConfig(m_eap); 
     1549    RouterConfig newcfg = EAP::RouterConfig(m_eap); 
    15301550 
    15311551    // upload the new router config 
     
    15381558 
    15391559bool 
    1540 Device::EAP::Router::hasPeakMetering() 
     1560EAP::Router::hasPeakMetering() 
    15411561{ 
    15421562    return m_eap.m_router_exposed; 
     
    15441564 
    15451565double 
    1546 Device::EAP::Router::getPeakValue(const int source, const int dest) 
     1566EAP::Router::getPeakValue(const int source, const int dest) 
    15471567{ 
    15481568    if((unsigned)source >= m_sources.size()) { 
     
    15831603 
    15841604Control::CrossbarRouter::PeakValues 
    1585 Device::EAP::Router::getPeakValues() 
     1605EAP::Router::getPeakValues() 
    15861606{ 
    15871607    m_peak.read(); 
     
    15981618 
    15991619void 
    1600 Device::EAP::Router::show() 
     1620EAP::Router::show() 
    16011621{ 
    16021622    // print the peak space as it also contains the routing configuration 
     
    16071627 
    16081628// ----------- routing config ------------- 
    1609 Device::EAP::RouterConfig::RouterConfig(EAP &p) 
     1629EAP::RouterConfig::RouterConfig(EAP &p) 
    16101630: m_eap(p) 
    16111631, m_base(eRT_None), m_offset(0) 
     
    16131633{} 
    16141634 
    1615 Device::EAP::RouterConfig::RouterConfig(EAP &p, enum eRegBase b, unsigned int o) 
     1635EAP::RouterConfig::RouterConfig(EAP &p, enum eRegBase b, unsigned int o) 
    16161636: m_eap(p) 
    16171637, m_base(b), m_offset(o) 
     
    16191639{} 
    16201640 
    1621 Device::EAP::RouterConfig::~RouterConfig() 
     1641EAP::RouterConfig::~RouterConfig() 
    16221642{} 
    16231643 
    16241644bool 
    1625 Device::EAP::RouterConfig::read(enum eRegBase base, unsigned offset) 
     1645EAP::RouterConfig::read(enum eRegBase base, unsigned offset) 
    16261646{ 
    16271647    // first clear the current route vector 
     
    16521672 
    16531673bool 
    1654 Device::EAP::RouterConfig::write(enum eRegBase base, unsigned offset) 
     1674EAP::RouterConfig::write(enum eRegBase base, unsigned offset) 
    16551675{ 
    16561676    uint32_t nb_routes = m_routes.size(); 
     
    16831703 
    16841704bool 
    1685 Device::EAP::RouterConfig::insertRoute(struct Route r, unsigned int index) 
     1705EAP::RouterConfig::insertRoute(struct Route r, unsigned int index) 
    16861706{ 
    16871707    unsigned int nb_routes = getNbRoutes(); 
     
    17011721 
    17021722bool 
    1703 Device::EAP::RouterConfig::replaceRoute(unsigned int old_index, struct Route new_route) 
     1723EAP::RouterConfig::replaceRoute(unsigned int old_index, struct Route new_route) 
    17041724{ 
    17051725    if(old_index >= getNbRoutes()) { 
     
    17151735 
    17161736bool 
    1717 Device::EAP::RouterConfig::replaceRoute(struct Route old_route, struct Route new_route) 
     1737EAP::RouterConfig::replaceRoute(struct Route old_route, struct Route new_route) 
    17181738{ 
    17191739    int idx = getRouteIndex(old_route); 
     
    17261746 
    17271747bool 
    1728 Device::EAP::RouterConfig::removeRoute(struct Route r) 
     1748EAP::RouterConfig::removeRoute(struct Route r) 
    17291749{ 
    17301750    int idx = getRouteIndex(r); 
     
    17371757 
    17381758bool 
    1739 Device::EAP::RouterConfig::removeRoute(unsigned int index) 
     1759EAP::RouterConfig::removeRoute(unsigned int index) 
    17401760{ 
    17411761    if(index >= getNbRoutes()) { 
     
    17491769 
    17501770int 
    1751 Device::EAP::RouterConfig::getRouteIndex(struct Route r) 
     1771EAP::RouterConfig::getRouteIndex(struct Route r) 
    17521772{ 
    17531773    int i = 0; 
     
    17631783} 
    17641784 
    1765 struct Device::EAP::RouterConfig::Route 
    1766 Device::EAP::RouterConfig::getRoute(unsigned int idx) 
     1785struct EAP::RouterConfig::Route 
     1786EAP::RouterConfig::getRoute(unsigned int idx) 
    17671787{ 
    17681788    if( (idx < 0) || (idx >= m_routes.size()) ) { 
     
    17751795 
    17761796#define CASE_INT_EQUAL_RETURN(_x) case (int)(_x): return _x; 
    1777 enum Device::EAP::eRouteDestination 
    1778 Device::EAP::RouterConfig::intToRouteDestination(int dst) 
     1797enum EAP::eRouteDestination 
     1798EAP::RouterConfig::intToRouteDestination(int dst) 
    17791799{ 
    17801800    switch(dst) { 
     
    17931813} 
    17941814 
    1795 enum Device::EAP::eRouteSource 
    1796 Device::EAP::RouterConfig::intToRouteSource(int src) 
     1815enum EAP::eRouteSource 
     1816EAP::RouterConfig::intToRouteSource(int src) 
    17971817{ 
    17981818    switch(src) { 
     
    18101830} 
    18111831 
    1812 struct Device::EAP::RouterConfig::Route 
    1813 Device::EAP::RouterConfig::decodeRoute(uint32_t val) { 
     1832struct EAP::RouterConfig::Route 
     1833EAP::RouterConfig::decodeRoute(uint32_t val) { 
    18141834    int routerval = val & 0xFFFF; 
    18151835    int peak = (val >> 16) & 0x0FFF; 
     
    18231843 
    18241844uint32_t 
    1825 Device::EAP::RouterConfig::encodeRoute(struct Route r) { 
     1845EAP::RouterConfig::encodeRoute(struct Route r) { 
    18261846    if(r.src == eRS_Invalid || r.dst == eRD_Invalid) { 
    18271847        debugWarning("Encoding invalid source/dest (%d/%d)\n", r.src, r.dst); 
     
    18401860} 
    18411861 
    1842 struct Device::EAP::RouterConfig::Route 
    1843 Device::EAP::RouterConfig::getRouteForDestination(enum eRouteDestination dst, int channel) 
     1862struct EAP::RouterConfig::Route 
     1863EAP::RouterConfig::getRouteForDestination(enum eRouteDestination dst, int channel) 
    18441864{ 
    18451865    for ( RouteVectorIterator it = m_routes.begin(); 
     
    18611881} 
    18621882 
    1863 std::vector<struct Device::EAP::RouterConfig::Route> 
    1864 Device::EAP::RouterConfig::getRoutesForSource(enum eRouteSource src, int channel) 
     1883std::vector<struct EAP::RouterConfig::Route> 
     1884EAP::RouterConfig::getRoutesForSource(enum eRouteSource src, int channel) 
    18651885{ 
    18661886    std::vector<struct Route>routes; 
     
    18811901 
    18821902void 
    1883 Device::EAP::RouterConfig::show() 
     1903EAP::RouterConfig::show() 
    18841904{ 
    18851905    for ( RouteVectorIterator it = m_routes.begin(); 
     
    18981918 
    18991919bool 
    1900 Device::EAP::PeakSpace::read(enum eRegBase base, unsigned offset) 
     1920EAP::PeakSpace::read(enum eRegBase base, unsigned offset) 
    19011921{ 
    19021922    // first clear the current route vector 
     
    19291949 
    19301950bool 
    1931 Device::EAP::PeakSpace::write(enum eRegBase base, unsigned offset) 
     1951EAP::PeakSpace::write(enum eRegBase base, unsigned offset) 
    19321952{ 
    19331953    debugError("Peak space is read-only\n"); 
     
    19361956 
    19371957void 
    1938 Device::EAP::PeakSpace::show() 
     1958EAP::PeakSpace::show() 
    19391959{ 
    19401960    for ( RouteVectorIterator it = m_routes.begin(); 
     
    19511971 
    19521972// ----------- stream config block ------------- 
    1953 Device::EAP::StreamConfig::StreamConfig(EAP &p, enum eRegBase b, unsigned int o) 
     1973EAP::StreamConfig::StreamConfig(EAP &p, enum eRegBase b, unsigned int o) 
    19541974: m_eap(p) 
    19551975, m_base(b), m_offset(o) 
     
    19611981} 
    19621982 
    1963 Device::EAP::StreamConfig::~StreamConfig() 
     1983EAP::StreamConfig::~StreamConfig() 
    19641984{ 
    19651985    if(m_tx_configs) delete[]m_tx_configs; 
     
    19681988 
    19691989bool 
    1970 Device::EAP::StreamConfig::read(enum eRegBase base, unsigned offset) 
     1990EAP::StreamConfig::read(enum eRegBase base, unsigned offset) 
    19711991{ 
    19721992    if(!m_eap.readRegBlock(base, offset, &m_nb_tx, 4)) { 
     
    20172037 
    20182038bool 
    2019 Device::EAP::StreamConfig::write(enum eRegBase base, unsigned offset) 
     2039EAP::StreamConfig::write(enum eRegBase base, unsigned offset) 
    20202040{ 
    20212041    if(!m_eap.writeRegBlock(base, offset, &m_nb_tx, 4)) { 
     
    20492069} 
    20502070 
    2051 Device::diceNameVector 
    2052 Device::EAP::StreamConfig::getNamesForBlock(struct ConfigBlock &b) 
     2071diceNameVector 
     2072EAP::StreamConfig::getNamesForBlock(struct ConfigBlock &b) 
    20532073{ 
    20542074    diceNameVector names; 
     
    20682088 
    20692089void 
    2070 Device::EAP::StreamConfig::showConfigBlock(struct ConfigBlock &b) 
     2090EAP::StreamConfig::showConfigBlock(struct ConfigBlock &b) 
    20712091{ 
    20722092    debugOutput(DEBUG_LEVEL_VERBOSE, " Channel count : %u audio, %u midi\n", b.nb_audio, b.nb_midi); 
     
    20832103 
    20842104void 
    2085 Device::EAP::StreamConfig::show() 
     2105EAP::StreamConfig::show() 
    20862106{ 
    20872107    for(unsigned int i=0; i<m_nb_tx; i++) { 
  • trunk/libffado/src/dice/dice_eap.h

    r1630 r1766  
    2121 * 
    2222 */ 
     23#ifndef __DICE_EAP_H 
     24#define __DICE_EAP_H 
     25 
     26#include "dice_avdevice.h" 
    2327 
    2428#define DICE_EAP_BASE                  0x0000000000200000ULL 
     
    117121#define DICE_EAP_CHANNEL_CONFIG_NAMESTR_LEN_QUADS  (64) 
    118122#define DICE_EAP_CHANNEL_CONFIG_NAMESTR_LEN_BYTES  (4*DICE_EAP_CHANNEL_CONFIG_NAMESTR_LEN_QUADS) 
     123 
     124namespace Dice { 
     125 
     126/** 
     127 * this class represents the EAP interface 
     128 * available on some devices 
     129 */ 
     130class EAP : public Control::Container 
     131{ 
     132public: 
     133    enum eWaitReturn { 
     134        eWR_Error, 
     135        eWR_Timeout, 
     136        eWR_Busy, 
     137        eWR_Done, 
     138    }; 
     139    enum eRegBase { 
     140        eRT_Base, 
     141        eRT_Capability, 
     142        eRT_Command, 
     143        eRT_Mixer, 
     144        eRT_Peak, 
     145        eRT_NewRouting, 
     146        eRT_NewStreamCfg, 
     147        eRT_CurrentCfg, 
     148        eRT_Standalone, 
     149        eRT_Application, 
     150        eRT_None, 
     151    }; 
     152    enum eRouteSource { 
     153        eRS_AES = 0, 
     154        eRS_ADAT = 1, 
     155        eRS_Mixer = 2, 
     156        eRS_InS0 = 4, 
     157        eRS_InS1 = 5, 
     158        eRS_ARM = 10, 
     159        eRS_ARX0 = 11, 
     160        eRS_ARX1 = 12, 
     161        eRS_Muted = 15, 
     162        eRS_Invalid = 16, 
     163    }; 
     164    enum eRouteDestination { 
     165        eRD_AES = 0, 
     166        eRD_ADAT = 1, 
     167        eRD_Mixer0 = 2, 
     168        eRD_Mixer1 = 3, 
     169        eRD_InS0 = 4, 
     170        eRD_InS1 = 5, 
     171        eRD_ARM = 10, 
     172        eRD_ATX0 = 11, 
     173        eRD_ATX1 = 12, 
     174        eRD_Muted = 15, 
     175        eRD_Invalid = 16, 
     176    }; 
     177 
     178public: 
     179 
     180    // ---------- 
     181    class RouterConfig { 
     182    public: 
     183        struct Route 
     184        { 
     185            enum eRouteSource src; 
     186            int srcChannel; 
     187            enum eRouteDestination dst; 
     188            int dstChannel; 
     189            int peak; 
     190        }; 
     191        typedef std::vector<RouterConfig::Route> RouteVector; 
     192        typedef std::vector<RouterConfig::Route>::iterator RouteVectorIterator; 
     193        RouterConfig(EAP &); 
     194        RouterConfig(EAP &, enum eRegBase, unsigned int offset); 
     195        virtual ~RouterConfig(); 
     196 
     197        virtual bool read() {return read(m_base, m_offset);}; 
     198        virtual bool write() {return write(m_base, m_offset);}; 
     199        virtual bool read(enum eRegBase b, unsigned offset); 
     200        virtual bool write(enum eRegBase b, unsigned offset); 
     201        virtual void show(); 
     202 
     203 
     204        bool insertRoute(struct Route r) 
     205            {return insertRoute(r, m_routes.size());}; 
     206        bool insertRoute(struct Route r, unsigned int index); 
     207        bool replaceRoute(unsigned int old_index, struct Route new_route); 
     208        bool replaceRoute(struct Route old_route, struct Route new_route); 
     209        bool removeRoute(struct Route r); 
     210        bool removeRoute(unsigned int index); 
     211        int getRouteIndex(struct Route r); 
     212        struct Route getRoute(unsigned int index); 
     213 
     214        unsigned int getNbRoutes() {return m_routes.size();}; 
     215 
     216        struct Route getRouteForDestination(enum eRouteDestination dst, int channel); 
     217        RouteVector getRoutesForSource(enum eRouteSource src, int channel); 
     218 
     219        struct Route decodeRoute(uint32_t val); 
     220        uint32_t encodeRoute(struct Route r); 
     221    public: 
     222        static enum eRouteDestination intToRouteDestination(int); 
     223        static enum eRouteSource intToRouteSource(int); 
     224    protected: 
     225        EAP &m_eap; 
     226        enum eRegBase m_base; 
     227        unsigned int m_offset; 
     228        RouteVector m_routes; 
     229    protected: 
     230        DECLARE_DEBUG_MODULE_REFERENCE; 
     231    }; 
     232 
     233    // ---------- 
     234    // the peak space is a special version of a router config 
     235    class PeakSpace : public RouterConfig { 
     236    public: 
     237        PeakSpace(EAP &p) : RouterConfig(p, eRT_Peak, 0) {}; 
     238        virtual ~PeakSpace() {}; 
     239 
     240        virtual bool read() {return read(m_base, m_offset);}; 
     241        virtual bool write() {return write(m_base, m_offset);}; 
     242        virtual bool read(enum eRegBase b, unsigned offset); 
     243        virtual bool write(enum eRegBase b, unsigned offset); 
     244        virtual void show(); 
     245    }; 
     246 
     247    // ---------- 
     248    class StreamConfig { 
     249    public: 
     250        struct ConfigBlock { // FIXME: somewhere in the DICE avdevice this is present too 
     251            uint32_t nb_audio; 
     252            uint32_t nb_midi; 
     253            uint32_t names[DICE_EAP_CHANNEL_CONFIG_NAMESTR_LEN_QUADS]; 
     254            uint32_t ac3_map; 
     255        }; 
     256        void showConfigBlock(struct ConfigBlock &); 
     257        diceNameVector getNamesForBlock(struct ConfigBlock &b); 
     258    public: 
     259        StreamConfig(EAP &, enum eRegBase, unsigned int offset); 
     260        ~StreamConfig(); 
     261 
     262        bool read() {return read(m_base, m_offset);}; 
     263        bool write() {return write(m_base, m_offset);}; 
     264        bool read(enum eRegBase b, unsigned offset); 
     265        bool write(enum eRegBase b, unsigned offset); 
     266 
     267        void show(); 
     268 
     269    private: 
     270        EAP &m_eap; 
     271        enum eRegBase m_base; 
     272        unsigned int m_offset; 
     273 
     274        uint32_t m_nb_tx; 
     275        uint32_t m_nb_rx; 
     276 
     277        struct ConfigBlock *m_tx_configs; 
     278        struct ConfigBlock *m_rx_configs; 
     279 
     280        DECLARE_DEBUG_MODULE_REFERENCE; 
     281    }; 
     282 
     283public: // mixer control subclass 
     284    class Mixer : public Control::MatrixMixer { 
     285    public: 
     286        Mixer(EAP &); 
     287        ~Mixer(); 
     288 
     289        bool init(); 
     290        void show(); 
     291 
     292        void updateNameCache(); 
     293        /** 
     294         * load the coefficients from the device into the local cache 
     295         * @return  
     296         */ 
     297        bool loadCoefficients(); 
     298        /** 
     299         * Stores the coefficients from the cache to the device 
     300         * @return  
     301         */ 
     302        bool storeCoefficients(); 
     303 
     304        virtual int getRowCount( ); 
     305        virtual int getColCount( ); 
     306 
     307        virtual int canWrite( const int, const int ); 
     308        virtual double setValue( const int, const int, const double ); 
     309        virtual double getValue( const int, const int ); 
     310 
     311        bool hasNames() const { return true; } 
     312        std::string getRowName( const int ); 
     313        std::string getColName( const int ); 
     314 
     315        // TODO: implement connections. 
     316        bool canConnect() const { return false; } 
     317 
     318        // full map updates are unsupported 
     319        virtual bool getCoefficientMap(int &); 
     320        virtual bool storeCoefficientMap(int &); 
     321 
     322    private: 
     323        EAP &         m_eap; 
     324        fb_quadlet_t *m_coeff; 
     325 
     326        std::map<int, RouterConfig::Route> m_input_route_map; 
     327        std::map<int, RouterConfig::RouteVector> m_output_route_map; 
     328 
     329        DECLARE_DEBUG_MODULE_REFERENCE; 
     330    }; 
     331 
     332    // ---------- 
     333    class Router : public Control::CrossbarRouter { 
     334    private: 
     335        struct Source { 
     336            std::string name; 
     337            enum eRouteSource src; 
     338            int srcChannel; 
     339        }; 
     340        typedef std::vector<Source> SourceVector; 
     341        typedef std::vector<Source>::iterator SourceVectorIterator; 
     342 
     343        struct Destination { 
     344            std::string name; 
     345            enum eRouteDestination dst; 
     346            int dstChannel; 
     347        }; 
     348        typedef std::vector<Destination> DestinationVector; 
     349        typedef std::vector<Destination>::iterator DestinationVectorIterator; 
     350 
     351    public: 
     352        Router(EAP &); 
     353        ~Router(); 
     354 
     355        void show(); 
     356 
     357        // to be subclassed by the implementing 
     358        // devices 
     359        virtual void setupSources(); 
     360        virtual void setupDestinations(); 
     361 
     362        void setupDestinationsAddDestination(const char *name, enum eRouteDestination dstid, 
     363                                             unsigned int base, unsigned int cnt); 
     364        void setupSourcesAddSource(const char *name, enum eRouteSource srcid, 
     365                                   unsigned int base, unsigned int cnt); 
     366 
     367        int getDestinationIndex(enum eRouteDestination dstid, int channel); 
     368        int getSourceIndex(enum eRouteSource srcid, int channel); 
     369 
     370        // per-coefficient access 
     371        virtual std::string getSourceName(const int); 
     372        virtual std::string getDestinationName(const int); 
     373        virtual int getSourceIndex(std::string); 
     374        virtual int getDestinationIndex(std::string); 
     375        virtual NameVector getSourceNames(); 
     376        virtual NameVector getDestinationNames(); 
     377 
     378        virtual Control::CrossbarRouter::Groups getSources(); 
     379        virtual Control::CrossbarRouter::Groups getDestinations(); 
     380 
     381        virtual IntVector getDestinationsForSource(const int); 
     382        virtual int getSourceForDestination(const int); 
     383 
     384        virtual bool canConnect( const int source, const int dest); 
     385        virtual bool setConnectionState( const int source, const int dest, const bool enable); 
     386        virtual bool getConnectionState( const int source, const int dest ); 
     387 
     388        virtual bool canConnect(std::string, std::string); 
     389        virtual bool setConnectionState(std::string, std::string, const bool enable); 
     390        virtual bool getConnectionState(std::string, std::string); 
     391 
     392        virtual bool clearAllConnections(); 
     393 
     394        virtual int getNbSources(); 
     395        virtual int getNbDestinations(); 
     396 
     397        // functions to access the entire routing map at once 
     398        // idea is that the row/col nodes that are 1 get a routing entry 
     399        virtual bool getConnectionMap(int *); 
     400        virtual bool setConnectionMap(int *); 
     401 
     402        // peak metering support 
     403        virtual bool hasPeakMetering(); 
     404        virtual bool getPeakValues(double &) {return false;}; 
     405        virtual double getPeakValue(const int source, const int dest); 
     406        virtual Control::CrossbarRouter::PeakValues getPeakValues(); 
     407 
     408    private: 
     409        EAP &m_eap; 
     410        // these contain the sources and destinations available for this 
     411        // router 
     412        SourceVector      m_sources; 
     413        DestinationVector m_destinations; 
     414 
     415        PeakSpace &m_peak; 
     416 
     417        DECLARE_DEBUG_MODULE_REFERENCE; 
     418    }; 
     419 
     420public: 
     421    EAP(Device &); 
     422    virtual ~EAP(); 
     423 
     424    static bool supportsEAP(Device &); 
     425    bool init(); 
     426 
     427    void show(); 
     428    void showApplication(); 
     429    enum eWaitReturn operationBusy(); 
     430    enum eWaitReturn waitForOperationEnd(int max_wait_time_ms = 100); 
     431 
     432    bool updateConfigurationCache(); 
     433    RouterConfig * getActiveRouterConfig(); 
     434    StreamConfig * getActiveStreamConfig(); 
     435 
     436    bool updateRouterConfig(RouterConfig&, bool low, bool mid, bool high); 
     437    bool updateCurrentRouterConfig(RouterConfig&); 
     438    bool updateStreamConfig(StreamConfig&, bool low, bool mid, bool high); 
     439    bool updateStreamConfig(RouterConfig&, StreamConfig&, bool low, bool mid, bool high); 
     440 
     441    bool loadFlashConfig(); 
     442    bool storeFlashConfig(); 
     443 
     444private: 
     445    bool loadRouterConfig(bool low, bool mid, bool high); 
     446    bool loadStreamConfig(bool low, bool mid, bool high); 
     447    bool loadRouterAndStreamConfig(bool low, bool mid, bool high); 
     448private: 
     449    bool     m_router_exposed; 
     450    bool     m_router_readonly; 
     451    bool     m_router_flashstored; 
     452    uint16_t m_router_nb_entries; 
     453 
     454    bool     m_mixer_exposed; 
     455    bool     m_mixer_readonly; 
     456    bool     m_mixer_flashstored; 
     457    uint8_t  m_mixer_tx_id; 
     458    uint8_t  m_mixer_rx_id; 
     459    uint8_t  m_mixer_nb_tx; 
     460    uint8_t  m_mixer_nb_rx; 
     461 
     462    bool     m_general_support_dynstream; 
     463    bool     m_general_support_flash; 
     464    bool     m_general_peak_enabled; 
     465    uint8_t  m_general_max_tx; 
     466    uint8_t  m_general_max_rx; 
     467    bool     m_general_stream_cfg_stored; 
     468    uint16_t m_general_chip; 
     469 
     470    bool commandHelper(fb_quadlet_t cmd); 
     471 
     472public: 
     473    bool readReg(enum eRegBase, unsigned offset, quadlet_t *); 
     474    bool writeReg(enum eRegBase, unsigned offset, quadlet_t); 
     475    bool readRegBlock(enum eRegBase, unsigned, fb_quadlet_t *, size_t); 
     476    bool writeRegBlock(enum eRegBase, unsigned, fb_quadlet_t *, size_t); 
     477    bool readRegBlockSwapped(enum eRegBase, unsigned, fb_quadlet_t *, size_t); 
     478    bool writeRegBlockSwapped(enum eRegBase, unsigned, fb_quadlet_t *, size_t); 
     479    fb_nodeaddr_t offsetGen(enum eRegBase, unsigned, size_t); 
     480 
     481protected: 
     482    DECLARE_DEBUG_MODULE; //_REFERENCE; 
     483 
     484private: 
     485    Device & m_device; 
     486    Mixer*   m_mixer; 
     487    Router*  m_router; 
     488    RouterConfig m_current_cfg_routing_low; 
     489    RouterConfig m_current_cfg_routing_mid; 
     490    RouterConfig m_current_cfg_routing_high; 
     491    StreamConfig m_current_cfg_stream_low; 
     492    StreamConfig m_current_cfg_stream_mid; 
     493    StreamConfig m_current_cfg_stream_high; 
     494public: 
     495    Mixer*  getMixer() {return m_mixer;}; 
     496    Router* getRouter() {return m_router;}; 
     497 
     498private: 
     499 
     500    fb_quadlet_t m_capability_offset; 
     501    fb_quadlet_t m_capability_size; 
     502    fb_quadlet_t m_cmd_offset; 
     503    fb_quadlet_t m_cmd_size; 
     504    fb_quadlet_t m_mixer_offset; 
     505    fb_quadlet_t m_mixer_size; 
     506    fb_quadlet_t m_peak_offset; 
     507    fb_quadlet_t m_peak_size; 
     508    fb_quadlet_t m_new_routing_offset; 
     509    fb_quadlet_t m_new_routing_size; 
     510    fb_quadlet_t m_new_stream_cfg_offset; 
     511    fb_quadlet_t m_new_stream_cfg_size; 
     512    fb_quadlet_t m_curr_cfg_offset; 
     513    fb_quadlet_t m_curr_cfg_size; 
     514    fb_quadlet_t m_standalone_offset; 
     515    fb_quadlet_t m_standalone_size; 
     516    fb_quadlet_t m_app_offset; 
     517    fb_quadlet_t m_app_size; 
     518}; 
     519 
     520}; 
     521 
     522#endif // __DICE_EAP_H 
  • trunk/libffado/src/dice/focusrite/focusrite_eap.cpp

    r1737 r1766  
    5151 
    5252 
    53 FocusriteEAP::FocusriteEAP(Dice::Device& dev) : Dice::Device::EAP(dev) { 
     53FocusriteEAP::FocusriteEAP(Dice::Device& dev) : Dice::EAP(dev) { 
    5454} 
    5555 
  • trunk/libffado/src/dice/focusrite/focusrite_eap.h

    r1734 r1766  
    2626#define DICE_FOCUSRITE_FOCUSRITE_EAP_H 
    2727 
    28 #include "dice/dice_avdevice.h" 
     28#include "dice/dice_eap.h" 
    2929 
    3030#include "libieee1394/configrom.h" 
     
    3333namespace Focusrite { 
    3434 
    35 class FocusriteEAP : public Dice::Device::EAP 
     35class FocusriteEAP : public Dice::EAP 
    3636{ 
    3737public: 
  • trunk/libffado/src/dice/focusrite/saffire_pro24.cpp

    r1734 r1766  
    9292    if (Dice::Device::discover()) { 
    9393        fb_quadlet_t* tmp = (fb_quadlet_t *)calloc(2, sizeof(fb_quadlet_t)); 
    94         getEAP()->readRegBlock(Dice::Device::EAP::eRT_Application, 0x00, tmp, 1*sizeof(fb_quadlet_t)); 
     94        getEAP()->readRegBlock(Dice::EAP::eRT_Application, 0x00, tmp, 1*sizeof(fb_quadlet_t)); 
    9595        //hexDumpQuadlets(tmp, 2); // DEBUG 
    9696        if (tmp[0] != 0x00010004 ) { 
     
    9999            return false; 
    100100        } 
    101         //getEAP()->readRegBlock(Dice::Device::EAP::eRT_Command, 0x00, tmp, 2*sizeof(fb_quadlet_t)); // DEBUG 
     101        //getEAP()->readRegBlock(Dice::EAP::eRT_Command, 0x00, tmp, 2*sizeof(fb_quadlet_t)); // DEBUG 
    102102        //hexDumpQuadlets(tmp, 2); // DEBUG 
    103103 
     
    124124    Dice::Device::showDevice(); 
    125125} 
    126 Dice::Device::EAP* SaffirePro24::createEAP() { 
     126Dice::EAP* SaffirePro24::createEAP() { 
    127127    return new SaffirePro24EAP(*this); 
    128128} 
    129129 
    130130bool SaffirePro24::setNickName( std::string name ) { 
    131     return getEAP()->writeRegBlock( Dice::Device::EAP::eRT_Application, 0x40, (fb_quadlet_t*)name.c_str(), name.size() ); 
     131    return getEAP()->writeRegBlock( Dice::EAP::eRT_Application, 0x40, (fb_quadlet_t*)name.c_str(), name.size() ); 
    132132} 
    133133 
    134134std::string SaffirePro24::getNickName() { 
    135135    char name[16]; 
    136     getEAP()->readRegBlock( Dice::Device::EAP::eRT_Application, 0x40, (fb_quadlet_t*)name, 16 ); 
     136    getEAP()->readRegBlock( Dice::EAP::eRT_Application, 0x40, (fb_quadlet_t*)name, 16 ); 
    137137    return std::string( name ); 
    138138} 
  • trunk/libffado/src/dice/focusrite/saffire_pro24.h

    r1734 r1766  
    6262        Poti* getDimPoti(std::string); 
    6363    }; 
    64     Dice::Device::EAP* createEAP(); 
     64    Dice::EAP* createEAP(); 
    6565 
    6666    class LineInstSwitch; 
  • trunk/libffado/src/dice/focusrite/saffire_pro40.cpp

    r1729 r1766  
    2424#include "saffire_pro40.h" 
    2525 
     26#include "focusrite_eap.h" 
     27 
    2628namespace Dice { 
    2729namespace Focusrite { 
     
    4749 
    4850bool SaffirePro40::setNickName(std::string name) { 
    49     return getEAP()->writeRegBlock(Dice::Device::EAP::eRT_Application, 0x44, (quadlet_t*)name.c_str(), name.size()); 
     51    return getEAP()->writeRegBlock(Dice::EAP::eRT_Application, 0x44, (quadlet_t*)name.c_str(), name.size()); 
    5052} 
    5153std::string SaffirePro40::getNickName() { 
    5254    char name[16]; 
    53     getEAP()->readRegBlock(Dice::Device::EAP::eRT_Application, 0x44, (quadlet_t*)name, 16); 
     55    getEAP()->readRegBlock(Dice::EAP::eRT_Application, 0x44, (quadlet_t*)name, 16); 
    5456    return std::string(name); 
    5557}