Changeset 932

Show
Ignore:
Timestamp:
03/11/08 05:46:25 (13 years ago)
Author:
ppalmers
Message:

- implement bus reset handling for the CTR DLL
- move the functor header to libutil

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/libffado/src/bebob/bebob_dl_mgr.h

    r864 r932  
    2828 
    2929#include "fbtypes.h" 
    30 #include "threads.h" 
     30#include "libutil/Functors.h" 
    3131 
    3232#include "debugmodule/debugmodule.h" 
     
    3636class Ieee1394Service; 
    3737class ConfigRom; 
     38 
     39using namespace Util; 
    3840 
    3941namespace BeBoB { 
  • trunk/libffado/src/devicemanager.cpp

    r909 r932  
    168168        } 
    169169        // add the bus reset handler 
    170         Functor* tmp_busreset_functor = new MemberFunctor0< DeviceManager*, 
     170        Util::Functor* tmp_busreset_functor = new Util::MemberFunctor0< DeviceManager*, 
    171171                    void (DeviceManager::*)() > 
    172172                    ( this, &DeviceManager::busresetHandler, false ); 
  • trunk/libffado/src/devicemanager.h

    r864 r932  
    5353typedef std::vector< Ieee1394Service* >::iterator Ieee1394ServiceVectorIterator; 
    5454 
    55 typedef std::vector< Functor* > FunctorVector; 
    56 typedef std::vector< Functor* >::iterator FunctorVectorIterator; 
     55typedef std::vector< Util::Functor* > FunctorVector; 
     56typedef std::vector< Util::Functor* >::iterator FunctorVectorIterator; 
    5757 
    5858class DeviceManager 
  • trunk/libffado/src/libieee1394/CycleTimerHelper.cpp

    r919 r932  
    7171    , m_realtime ( false ) 
    7272    , m_priority ( 0 ) 
     73    , m_busreset_functor ( NULL) 
     74    , m_unhandled_busreset ( false ) 
    7375{ 
    7476    debugOutput( DEBUG_LEVEL_VERBOSE, "Create %p...\n", this); 
     77    pthread_mutex_init(&mb_update_lock, NULL); 
    7578} 
    7679 
     
    9497    , m_realtime ( rt ) 
    9598    , m_priority ( prio ) 
     99    , m_busreset_functor ( NULL) 
     100    , m_unhandled_busreset ( false ) 
    96101{ 
    97102    debugOutput( DEBUG_LEVEL_VERBOSE, "Create %p...\n", this); 
     103    pthread_mutex_init(&mb_update_lock, NULL); 
    98104} 
    99105 
     
    104110        delete m_Thread; 
    105111    } 
     112 
     113    // unregister the bus reset handler 
     114    if(m_busreset_functor) { 
     115        m_Parent.remBusResetHandler( m_busreset_functor ); 
     116        delete m_busreset_functor; 
     117    } 
     118    pthread_mutex_destroy(&mb_update_lock); 
    106119} 
    107120 
     
    111124    debugOutput( DEBUG_LEVEL_VERBOSE, "Start %p...\n", this); 
    112125 
    113     // initialize the 'prev ctr' values 
    114     uint64_t local_time; 
    115     int maxtries2 = 10; 
    116     do { 
    117         if(!m_Parent.readCycleTimerReg(&m_cycle_timer_prev, &local_time)) { 
    118             debugError("Could not read cycle timer register\n"); 
    119             return false; 
    120         } 
    121         if (m_cycle_timer_prev == 0) { 
    122             debugOutput(DEBUG_LEVEL_VERBOSE, 
    123                         "Bogus CTR: %08X on try %02d\n", 
    124                         m_cycle_timer_prev, maxtries2); 
    125         } 
    126     } while (m_cycle_timer_prev == 0 && maxtries2--); 
    127     m_cycle_timer_ticks_prev = CYCLE_TIMER_TO_TICKS(m_cycle_timer_prev); 
    128  
    129 #if IEEE1394SERVICE_USE_CYCLETIMER_DLL 
    130     m_high_bw_updates = UPDATES_WITH_HIGH_BANDWIDTH; 
     126    if(!initValues()) { 
     127        debugFatal("(%p) Could not init values\n", this); 
     128        return false; 
     129    } 
     130 
    131131    m_Thread = new Util::PosixThread(this, m_realtime, m_priority,  
    132132                                     PTHREAD_CANCEL_DEFERRED); 
     
    139139        return false; 
    140140    } 
     141    return true; 
     142} 
     143 
     144bool 
     145CycleTimerHelper::initValues() 
     146{ 
     147    debugOutput( DEBUG_LEVEL_VERBOSE, "Init values...\n" ); 
     148    pthread_mutex_lock(&mb_update_lock); 
     149    // initialize the 'prev ctr' values 
     150    uint64_t local_time; 
     151    int maxtries2 = 10; 
     152    do { 
     153        debugOutput( DEBUG_LEVEL_VERBOSE, "Read CTR...\n" ); 
     154        if(!m_Parent.readCycleTimerReg(&m_cycle_timer_prev, &local_time)) { 
     155            debugError("Could not read cycle timer register\n"); 
     156            pthread_mutex_unlock(&mb_update_lock); 
     157            return false; 
     158        } 
     159        if (m_cycle_timer_prev == 0) { 
     160            debugOutput(DEBUG_LEVEL_VERBOSE, 
     161                        "Bogus CTR: %08X on try %02d\n", 
     162                        m_cycle_timer_prev, maxtries2); 
     163        } 
     164        debugOutput( DEBUG_LEVEL_VERBOSE, " read : CTR: %11lu, local: %17llu\n", 
     165                            m_cycle_timer_prev, local_time); 
     166        debugOutput(DEBUG_LEVEL_VERBOSE, 
     167                           "  ctr   : 0x%08X %11llu (%03us %04ucy %04uticks)\n", 
     168                           (uint32_t)m_cycle_timer_prev, (uint64_t)CYCLE_TIMER_TO_TICKS(m_cycle_timer_prev), 
     169                           (unsigned int)CYCLE_TIMER_GET_SECS( m_cycle_timer_prev ), 
     170                           (unsigned int)CYCLE_TIMER_GET_CYCLES( m_cycle_timer_prev ), 
     171                           (unsigned int)CYCLE_TIMER_GET_OFFSET( m_cycle_timer_prev ) ); 
     172         
     173    } while (m_cycle_timer_prev == 0 && maxtries2--); 
     174    m_cycle_timer_ticks_prev = CYCLE_TIMER_TO_TICKS(m_cycle_timer_prev); 
     175 
     176#if IEEE1394SERVICE_USE_CYCLETIMER_DLL 
     177    debugOutput( DEBUG_LEVEL_VERBOSE, "requesting DLL re-init...\n" ); 
     178    m_TimeSource.SleepUsecRelative(1000); // some time to settle 
     179    m_high_bw_updates = UPDATES_WITH_HIGH_BANDWIDTH; 
     180    if(!initDLL()) { 
     181        debugError("(%p) Could not init DLL\n", this); 
     182        pthread_mutex_unlock(&mb_update_lock); 
     183        return false; 
     184    } 
     185    // make the DLL re-init itself as if it were started up 
     186    m_first_run = true; 
    141187#endif 
     188    pthread_mutex_unlock(&mb_update_lock); 
     189    debugOutput( DEBUG_LEVEL_VERBOSE, "ready...\n" ); 
    142190    return true; 
    143191} 
     
    147195{ 
    148196    debugOutput( DEBUG_LEVEL_VERBOSE, "Initialize %p...\n", this); 
    149     return true; 
     197 
     198    // register a bus reset handler 
     199    Util::Functor* m_busreset_functor = new Util::MemberFunctor0< CycleTimerHelper*, 
     200                void (CycleTimerHelper::*)() > 
     201                ( this, &CycleTimerHelper::busresetHandler, false ); 
     202    if ( !m_busreset_functor ) { 
     203        debugFatal( "(%p) Could not create busreset handler\n", this ); 
     204        return false; 
     205    } 
     206    m_Parent.addBusResetHandler( m_busreset_functor ); 
     207 
     208    return true; 
     209
     210 
     211void 
     212CycleTimerHelper::busresetHandler() 
     213
     214    debugOutput( DEBUG_LEVEL_VERBOSE, "Bus reset...\n" ); 
     215    m_unhandled_busreset = true; 
     216    // whenever a bus reset occurs, the root node can change, 
     217    // and the CTR timer can be reset. We should hence reinit 
     218    // the DLL 
     219    if(!initValues()) { 
     220        debugError("(%p) Could not re-init values\n", this); 
     221    } 
     222    m_unhandled_busreset = false; 
    150223} 
    151224 
     
    187260 
    188261bool 
     262CycleTimerHelper::initDLL() { 
     263    uint32_t cycle_timer; 
     264    uint64_t local_time; 
     265    uint64_t cycle_timer_ticks; 
     266 
     267    if(!readCycleTimerWithRetry(&cycle_timer, &local_time, 10)) { 
     268        debugError("Could not read cycle timer register\n"); 
     269        pthread_mutex_unlock(&mb_update_lock); 
     270        return false; 
     271    } 
     272    cycle_timer_ticks = CYCLE_TIMER_TO_TICKS(cycle_timer); 
     273 
     274    debugOutputExtreme( DEBUG_LEVEL_VERY_VERBOSE, " read : CTR: %11lu, local: %17llu\n", 
     275                        cycle_timer, local_time); 
     276    debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, 
     277                       "  ctr   : 0x%08X %11llu (%03us %04ucy %04uticks)\n", 
     278                       (uint32_t)cycle_timer, (uint64_t)cycle_timer_ticks, 
     279                       (unsigned int)TICKS_TO_SECS( (uint64_t)cycle_timer_ticks ), 
     280                       (unsigned int)TICKS_TO_CYCLES( (uint64_t)cycle_timer_ticks ), 
     281                       (unsigned int)TICKS_TO_OFFSET( (uint64_t)cycle_timer_ticks ) ); 
     282 
     283    m_sleep_until = local_time + m_usecs_per_update; 
     284    m_dll_e2 = m_ticks_per_update; 
     285    m_current_time_usecs = local_time; 
     286    m_next_time_usecs = m_current_time_usecs + m_usecs_per_update; 
     287    m_current_time_ticks = CYCLE_TIMER_TO_TICKS( cycle_timer ); 
     288    m_next_time_ticks = addTicks( (uint64_t)m_current_time_ticks, (uint64_t)m_dll_e2); 
     289    debugOutput(DEBUG_LEVEL_VERBOSE, " First run\n"); 
     290    debugOutput(DEBUG_LEVEL_VERBOSE, 
     291                "  usecs/update: %lu, ticks/update: %lu, m_dll_e2: %f\n", 
     292                m_usecs_per_update, m_ticks_per_update, m_dll_e2); 
     293    debugOutput(DEBUG_LEVEL_VERBOSE, 
     294                "  usecs current: %f, next: %f\n", 
     295                m_current_time_usecs, m_next_time_usecs); 
     296    debugOutput(DEBUG_LEVEL_VERBOSE, 
     297                "  ticks current: %f, next: %f\n", 
     298                m_current_time_ticks, m_next_time_ticks); 
     299    return true; 
     300} 
     301 
     302bool 
    189303CycleTimerHelper::Execute() 
    190304{ 
    191305    debugOutputExtreme( DEBUG_LEVEL_VERY_VERBOSE, "Execute %p...\n", this); 
     306 
    192307    if (!m_first_run) { 
    193308        // wait for the next update period 
     309        #if DEBUG_EXTREME_ENABLE 
    194310        ffado_microsecs_t now = m_TimeSource.getCurrentTimeAsUsecs(); 
    195311        int sleep_time = m_sleep_until - now; 
    196312        debugOutputExtreme( DEBUG_LEVEL_VERY_VERBOSE, "(%p) Sleep until %lld/%f (now: %lld, diff=%d) ...\n", 
    197313                    this, m_sleep_until, m_next_time_usecs, now, sleep_time); 
     314        #endif 
    198315        m_TimeSource.SleepUsecAbsolute(m_sleep_until); 
    199316        debugOutputExtreme( DEBUG_LEVEL_VERY_VERBOSE, " (%p) back...\n", this); 
    200317    } 
     318 
     319    // grab the lock after sleeping, otherwise we can't be interrupted by 
     320    // the busreset thread (lower prio) 
     321    pthread_mutex_lock(&mb_update_lock); 
    201322 
    202323    uint32_t cycle_timer; 
     
    214335        if(!readCycleTimerWithRetry(&cycle_timer, &local_time, 10)) { 
    215336            debugError("Could not read cycle timer register\n"); 
     337            pthread_mutex_unlock(&mb_update_lock); 
    216338            return false; 
    217339        } 
     
    227349        } 
    228350 
    229     } while(diff_ticks < -((double)TICKS_PER_HALFCYCLE) && --ntries && !m_first_run); 
     351    } while( diff_ticks < -((double)TICKS_PER_HALFCYCLE)  
     352             && --ntries && !m_first_run && !m_unhandled_busreset); 
     353 
     354    if(m_unhandled_busreset) { 
     355        debugOutput(DEBUG_LEVEL_VERBOSE, 
     356                    "(%p) Skipping DLL update due to unhandled busreset\n", this); 
     357        m_sleep_until += m_usecs_per_update; 
     358        pthread_mutex_unlock(&mb_update_lock); 
     359        // keep the thread running 
     360        return true; 
     361    } 
    230362 
    231363    debugOutputExtreme( DEBUG_LEVEL_VERY_VERBOSE, " read : CTR: %11lu, local: %17llu\n", 
    232364                        cycle_timer, local_time); 
    233         debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, 
    234                            "  ctr   : 0x%08X %11llu (%03us %04ucy %04uticks)\n", 
    235                            (uint32_t)cycle_timer, (uint64_t)cycle_timer_ticks, 
    236                            (unsigned int)TICKS_TO_SECS( (uint64_t)cycle_timer_ticks ), 
    237                            (unsigned int)TICKS_TO_CYCLES( (uint64_t)cycle_timer_ticks ), 
    238                            (unsigned int)TICKS_TO_OFFSET( (uint64_t)cycle_timer_ticks ) ); 
     365    debugOutputExtreme(DEBUG_LEVEL_VERY_VERBOSE, 
     366                       "  ctr   : 0x%08X %11llu (%03us %04ucy %04uticks)\n", 
     367                       (uint32_t)cycle_timer, (uint64_t)cycle_timer_ticks, 
     368                       (unsigned int)TICKS_TO_SECS( (uint64_t)cycle_timer_ticks ), 
     369                       (unsigned int)TICKS_TO_CYCLES( (uint64_t)cycle_timer_ticks ), 
     370                       (unsigned int)TICKS_TO_OFFSET( (uint64_t)cycle_timer_ticks ) ); 
    239371 
    240372    if (m_first_run) { 
    241         m_sleep_until = local_time + m_usecs_per_update; 
    242         m_dll_e2 = m_ticks_per_update; 
    243         m_current_time_usecs = local_time; 
    244         m_next_time_usecs = m_current_time_usecs + m_usecs_per_update; 
    245         m_current_time_ticks = CYCLE_TIMER_TO_TICKS( cycle_timer ); 
    246         m_next_time_ticks = addTicks( (uint64_t)m_current_time_ticks, (uint64_t)m_dll_e2); 
    247         debugOutput(DEBUG_LEVEL_VERBOSE, " First run\n"); 
    248         debugOutput(DEBUG_LEVEL_VERBOSE, 
    249                     "  usecs/update: %lu, ticks/update: %lu, m_dll_e2: %f\n", 
    250                     m_usecs_per_update, m_ticks_per_update, m_dll_e2); 
    251         debugOutput(DEBUG_LEVEL_VERBOSE, 
    252                     "  usecs current: %f, next: %f\n", 
    253                     m_current_time_usecs, m_next_time_usecs); 
    254         debugOutput(DEBUG_LEVEL_VERBOSE, 
    255                     "  ticks current: %f, next: %f\n", 
    256                     m_current_time_ticks, m_next_time_ticks); 
     373        if(!initDLL()) { 
     374            debugError("(%p) Could not init DLL\n", this); 
     375            pthread_mutex_unlock(&mb_update_lock); 
     376            return false; 
     377        } 
    257378        m_first_run = false; 
    258379    } else { 
     
    390511    m_current_shadow_idx = next_idx; 
    391512 
     513    pthread_mutex_unlock(&mb_update_lock); 
    392514    return true; 
    393515} 
  • trunk/libffado/src/libieee1394/CycleTimerHelper.h

    r919 r932  
    5454#include "cycletimer.h" 
    5555 
     56#include "libutil/Functors.h" 
     57 
    5658#include "debugmodule/debugmodule.h" 
    5759 
     
    98100    float getNominalRate(); 
    99101 
     102    /** 
     103     * @brief handle a bus reset 
     104     */ 
     105    void busresetHandler(); 
     106 
    100107    void setVerboseLevel(int l); 
    101108 
    102109private: 
    103110    bool readCycleTimerWithRetry(uint32_t *cycle_timer, uint64_t *local_time, int ntries); 
     111    bool initValues(); 
     112 
     113#if IEEE1394SERVICE_USE_CYCLETIMER_DLL 
     114    bool initDLL(); 
     115#endif 
    104116 
    105117    Ieee1394Service &m_Parent; 
     
    140152    bool            m_realtime; 
    141153    unsigned int    m_priority; 
     154    pthread_mutex_t mb_update_lock; 
     155 
     156    // busreset handling 
     157    Util::Functor* m_busreset_functor; 
     158    bool            m_unhandled_busreset; 
    142159 
    143160    // debug stuff 
  • trunk/libffado/src/libieee1394/ieee1394service.cpp

    r914 r932  
    621621          ++it ) 
    622622    { 
    623         Functor* func = *it; 
     623        Util::Functor* func = *it; 
    624624        ( *func )(); 
    625625    } 
     
    815815 
    816816bool 
    817 Ieee1394Service::addBusResetHandler( Functor* functor ) 
     817Ieee1394Service::addBusResetHandler( Util::Functor* functor ) 
    818818{ 
    819819    debugOutput(DEBUG_LEVEL_VERBOSE, "Adding busreset handler (%p)\n", functor); 
     
    823823 
    824824bool 
    825 Ieee1394Service::remBusResetHandler( Functor* functor ) 
     825Ieee1394Service::remBusResetHandler( Util::Functor* functor ) 
    826826{ 
    827827    debugOutput(DEBUG_LEVEL_VERBOSE, "Removing busreset handler (%p)\n", functor); 
  • trunk/libffado/src/libieee1394/ieee1394service.h

    r909 r932  
    2727 
    2828#include "fbtypes.h" 
    29 #include "threads.h" 
     29#include "libutil/Functors.h" 
    3030 
    3131#include "debugmodule/debugmodule.h" 
     
    229229    int getVerboseLevel(); 
    230230 
    231     bool addBusResetHandler( Functor* functor ); 
    232     bool remBusResetHandler( Functor* functor ); 
     231    bool addBusResetHandler( Util::Functor* functor ); 
     232    bool remBusResetHandler( Util::Functor* functor ); 
    233233 
    234234    /** 
     
    331331    Util::TimeSource*   m_pTimeSource; 
    332332 
    333     typedef std::vector< Functor* > reset_handler_vec_t; 
     333    typedef std::vector< Util::Functor* > reset_handler_vec_t; 
    334334    reset_handler_vec_t m_busResetHandlers; 
    335335 
  • trunk/libffado/src/libutil/Functors.h

    r864 r932  
    2222 */ 
    2323 
    24 #ifndef THREADS_H 
    25 #define THREADS_H 
     24#ifndef __FFADO_FUNCTORS__ 
     25#define __FFADO_FUNCTORS__ 
    2626 
    2727#include <semaphore.h> 
     28 
     29namespace Util { 
    2830 
    2931class Functor 
     
    132134}; 
    133135 
     136}; // end of namespace Util 
     137 
    134138#endif 
    135139 
  • trunk/libffado/tests/test-ieee1394service.cpp

    r923 r932  
    4444 
    4545#include "src/libutil/Thread.h" 
     46#include "src/libutil/Functors.h" 
    4647#include "src/libutil/PosixThread.h" 
    4748#include <libraw1394/raw1394.h> 
     
    4950 
    5051 
    51 #define NB_THREADS 2 
     52#define NB_THREADS 1 
    5253#define THREAD_RT  true 
    5354#define THREAD_PRIO 51 
    54 #define THREAD_SLEEP_US 125 
     55#define THREAD_SLEEP_US 50000 
    5556 
    5657#define DISP_CYCLE_SLEEP_SECS 2 
     
    6263#define DIFF_CONSIDERED_LARGE (TICKS_PER_CYCLE/2) 
    6364int PORT_TO_USE = 0; 
     65int VERBOSE_LEVEL = 4; 
    6466 
    6567int max_diff=-99999; 
     
    9294        virtual bool Init() 
    9395        { 
    94             debugOutput(DEBUG_LEVEL_NORMAL, "(%p) Execute\n", this); 
     96            debugOutput(DEBUG_LEVEL_NORMAL, "(%p) Init\n", this); 
    9597            ctr = 0; 
    9698            ctr_dll = 0; 
     
    132134 
    133135bool CtrThread::Execute() { 
    134     debugOutput(DEBUG_LEVEL_VERBOSE, "(%p) Execute\n", this); 
     136    debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "(%p) Execute\n", this); 
    135137     
    136138    SleepRelativeUsec(THREAD_SLEEP_US); 
     
    162164        debugError("(%p) CTR read error\n", this); 
    163165    } 
    164     debugOutput ( DEBUG_LEVEL_VERBOSE, 
     166    debugOutput ( DEBUG_LEVEL_VERY_VERBOSE, 
    165167                "(%p) Cycle timer: %011llu (%03us %04ucy %04uticks)\n", 
    166168                this, ctr, 
     
    168170                (unsigned int)TICKS_TO_CYCLES( ctr ), 
    169171                (unsigned int)TICKS_TO_OFFSET( ctr ) ); 
    170     debugOutput ( DEBUG_LEVEL_VERBOSE, 
     172    debugOutput ( DEBUG_LEVEL_VERY_VERBOSE, 
    171173                "(%p)    from DLL: %011llu (%03us %04ucy %04uticks)\n", 
    172174                this, ctr_dll, 
     
    197199        abs_diff = diff; 
    198200    } 
    199     debugOutput ( DEBUG_LEVEL_VERBOSE, 
     201    debugOutput ( DEBUG_LEVEL_VERY_VERBOSE, 
    200202                "(%p)       diff: %s%011llu (%03us %04ucy %04uticks)\n", this, 
    201203                ((int64_t)abs_diff==diff?" ":"-"), abs_diff, (unsigned int)TICKS_TO_SECS( abs_diff ), 
     
    259261    if (tmp_orig != tmp_ctr) { 
    260262        debugError("CTR => TICKS => CTR failed\n"); 
    261         debugOutput ( DEBUG_LEVEL_VERBOSE, 
     263        debugOutput ( DEBUG_LEVEL_VERY_VERBOSE, 
    262264                    "(%p) orig CTR : %08X (%03us %04ucy %04uticks)\n", 
    263265                    this, (uint32_t)tmp_orig, 
     
    265267                    (unsigned int)CYCLE_TIMER_GET_CYCLES( tmp_orig ), 
    266268                    (unsigned int)CYCLE_TIMER_GET_OFFSET( tmp_orig ) ); 
    267         debugOutput ( DEBUG_LEVEL_VERBOSE, 
     269        debugOutput ( DEBUG_LEVEL_VERY_VERBOSE, 
    268270                    "(%p) TICKS: %011llu (%03us %04ucy %04uticks)\n", 
    269271                    this, tmp_ticks, 
     
    271273                    (unsigned int)TICKS_TO_CYCLES( tmp_ticks ), 
    272274                    (unsigned int)TICKS_TO_OFFSET( tmp_ticks ) ); 
    273         debugOutput ( DEBUG_LEVEL_VERBOSE, 
     275        debugOutput ( DEBUG_LEVEL_VERY_VERBOSE, 
    274276                    "(%p) new CTR : %08X (%03us %04ucy %04uticks)\n", 
    275277                    this, (uint32_t)tmp_ctr, 
     
    279281    } 
    280282     
    281     debugOutput ( DEBUG_LEVEL_VERBOSE, 
     283    debugOutput ( DEBUG_LEVEL_VERY_VERBOSE, 
    282284                "(%p)  wait...\n", this); 
    283285    return true; 
     
    287289{ 
    288290    int i=0; 
    289     setDebugLevel(DEBUG_LEVEL_NORMAL); 
    290291    signal (SIGINT, sighandler); 
    291292    signal (SIGPIPE, sighandler); 
    292293 
    293     static struct option long_opts[] = { { "port", 1, 0, 'p' }, { "help", 0, 0, 'h' }, { 0, 0, 0, 0 } }; 
     294    static struct option long_opts[] = { { "port", 1, 0, 'p' }, { "verbose", 1, 0, 'v' }, { "help", 0, 0, 'h' }, { 0, 0, 0, 0 } }; 
    294295    int optindex = 0; 
    295296    while(1) { 
     
    301302                PORT_TO_USE = atoi( optarg ); 
    302303                break; 
     304            case 'v': 
     305                VERBOSE_LEVEL = atoi( optarg ); 
     306                break; 
    303307            case 'h': 
    304308                printf( "USAGE:\n\ 
    305309 Currently two options are understood:\n\ 
    306310  --port <number> or -p <number> selects the firewire-port to use, default is 0\n\ 
     311  --verbose <number> or -v <number> selects the verbose level, default is 4\n\ 
    307312  --help or -h shows this help and exits.\n\ 
    308313" ); 
     
    313318 
    314319    printf("FFADO Ieee1394Service test application\n"); 
     320    printf(" Using port %d\n", PORT_TO_USE); 
     321    printf(" Verbose level %d\n", VERBOSE_LEVEL); 
     322 
     323    setDebugLevel(VERBOSE_LEVEL); 
    315324 
    316325    Ieee1394Service *m_service=NULL; 
    317326 
    318327    m_service = new Ieee1394Service(); 
    319     m_service->setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
     328    m_service->setVerboseLevel(VERBOSE_LEVEL); 
    320329    if(!m_service->initialize(PORT_TO_USE)) { 
    321330        printf("Could not initialize 1394 service\n");