Changeset 271

Show
Ignore:
Timestamp:
06/21/06 14:49:06 (16 years ago)
Author:
wagi
Message:

2006-06-21 Daniel Wagner <wagi@monom.org>

  • freebob-downloader first version added
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/libfreebob-downloader/ChangeLog

    r259 r271  
     12006-06-21  Daniel Wagner  <wagi@monom.org> 
     2 
     3        * freebob-downloader first version added 
     4 
    152006-06-10  Daniel Wagner  <wagi@monom.org> 
    26 
  • branches/libfreebob-downloader/src/configrom.cpp

    r241 r271  
    2626 
    2727#include <iostream> 
     28#include <iomanip> 
    2829 
    2930using namespace std; 
     
    6162    , m_vendorName( "" ) 
    6263    , m_modelName( "" ) 
     64    , m_vendorId( 0 ) 
     65    , m_modelId( 0 ) 
     66    , m_isIsoResourceManager( false ) 
     67    , m_isCycleMasterCapable( false ) 
     68    , m_isSupportIsoOperations( false ) 
     69    , m_isBusManagerCapable( false ) 
     70    , m_cycleClkAcc( 0 ) 
     71    , m_maxRec( 0 ) 
     72    , m_nodeVendorId( 0 ) 
     73    , m_chipIdHi( 0 ) 
     74    , m_chipIdLow( 0 ) 
    6375    , m_vendorNameKv( 0 ) 
    6476    , m_modelNameKv( 0 ) 
     
    90102    } 
    91103 
     104    // Process Bus_Info_Block 
     105    m_isIsoResourceManager = m_csr->bus_info_data[2] >> 31; 
     106    m_isCycleMasterCapable = ( m_csr->bus_info_data[2] >> 30 ) & 0x1; 
     107    m_isSupportIsoOperations = ( m_csr->bus_info_data[2] >> 29 ) & 0x1; 
     108    m_isBusManagerCapable = ( m_csr->bus_info_data[2] >> 28 ) & 0x1; 
     109    m_cycleClkAcc = ( m_csr->bus_info_data[2] >> 16 ) & 0xff; 
     110    m_maxRec = ( m_csr->bus_info_data[2] >> 12 ) & 0xf; 
     111    m_nodeVendorId = ( m_csr->bus_info_data[3] >> 8 ); 
     112    m_chipIdHi = ( m_csr->bus_info_data[3] ) & 0xff; 
     113    m_chipIdLow = m_csr->bus_info_data[4]; 
     114 
     115    // Process Root Directory 
    92116    processRootDirectory(m_csr); 
    93117 
     
    180204    struct config_csr_info* csr_info = (struct config_csr_info*) private_data; 
    181205 
    182     if ( csr_info->service->read( csr_info->nodeId, 
    183                                   addr, 
    184                                   length
    185                                   ( quadlet_t* )buffer) ) 
     206    if ( !csr_info->service->read( csr_info->nodeId, 
     207                                  addr, 
     208                                  length/4
     209                                  ( quadlet_t* )buffer) ) 
    186210    { 
    187211        //debugOutput( DEBUG_LEVEL_VERBOSE, "ConfigRom: Read failed\n"); 
     
    354378    return m_vendorName; 
    355379} 
     380 
     381bool 
     382ConfigRom::updatedNodeId() 
     383{ 
     384    for ( fb_nodeid_t nodeId = 0; 
     385          nodeId < m_1394Service->getNodeCount(); 
     386          ++nodeId ) 
     387    { 
     388        struct config_csr_info csr_info; 
     389        csr_info.service = m_1394Service; 
     390        csr_info.nodeId = 0xffc0 | nodeId; 
     391 
     392        struct csr1212_csr* csr = 
     393            csr1212_create_csr( &configrom_csr1212_ops, 
     394                                5 * sizeof(fb_quadlet_t),   // XXX Why 5 ?!? 
     395                                &csr_info ); 
     396 
     397        if (!csr || csr1212_parse_csr( csr ) != CSR1212_SUCCESS) { 
     398            if (csr) { 
     399                csr1212_destroy_csr(csr); 
     400            } 
     401            return false; 
     402        } 
     403 
     404 
     405        octlet_t guid = 
     406            ((u_int64_t)CSR1212_BE32_TO_CPU(csr->bus_info_data[3]) << 32) 
     407            | CSR1212_BE32_TO_CPU(csr->bus_info_data[4]); 
     408 
     409        if ( guid == m_guid ) { 
     410            if ( nodeId != m_nodeId ) { 
     411                debugOutput( DEBUG_LEVEL_VERBOSE, 
     412                             "Device with GUID 0%08x%08x changed node id " 
     413                             "from %d to %d\n", 
     414                             m_guid >> 32, 
     415                             m_guid & 0xffffffff, 
     416                             m_nodeId, 
     417                             nodeId ); 
     418                m_nodeId = nodeId; 
     419            } 
     420            return true; 
     421        } 
     422    } 
     423 
     424    debugOutput( DEBUG_LEVEL_NORMAL, 
     425                 "Device with GUID 0x%08x%08x could not be found on " 
     426                 "the bus anymore (removed?)\n", 
     427                 m_guid >> 32, 
     428                 m_guid & 0xffffffff ); 
     429    return false; 
     430} 
     431 
     432void 
     433ConfigRom::printConfigRom() const 
     434{ 
     435    using namespace std; 
     436    cout << "Config ROM" << endl; 
     437    cout << "\tCurrent Node Id:\t" << getNodeId() << endl; 
     438    cout << "\tGUID:\t\t\t0x" << setfill( '0' ) << setw( 16 ) << hex << getGuid() << endl; 
     439    cout << "\tVendor Name:\t\t" << getVendorName() << endl; 
     440    cout << "\tModel Name:\t\t" << getModelName() << endl; 
     441} 
     442 
     443unsigned short 
     444ConfigRom::getAsyMaxPayload() const 
     445{ 
     446    // XXX use pow instead 
     447    return 1 << ( m_maxRec + 1 ); 
     448} 
  • branches/libfreebob-downloader/src/configrom.h

    r241 r271  
    4444    const std::string getModelName() const; 
    4545    const std::string getVendorName() const; 
     46    bool isIsoResourseManager() const 
     47        { return m_isIsoResourceManager; } 
     48    bool isCycleMasterCapable() const 
     49        { return m_isCycleMasterCapable; } 
     50    bool isSupportsIsoOperations() const 
     51        { return m_isSupportIsoOperations; } 
     52    bool isBusManagerCapable() const 
     53        { return m_isBusManagerCapable; } 
     54    fb_byte_t getCycleClockAccurancy() const 
     55        { return m_cycleClkAcc; } 
     56    fb_byte_t getMaxRec() const 
     57        { return m_maxRec; } 
     58    unsigned short getAsyMaxPayload() const; 
    4659 
     60    bool updatedNodeId(); 
     61 
     62    void printConfigRom() const; 
    4763 
    4864 protected: 
     
    6177    unsigned int     m_vendorId; 
    6278    unsigned int     m_modelId; 
     79    bool             m_isIsoResourceManager; 
     80    bool             m_isCycleMasterCapable; 
     81    bool             m_isSupportIsoOperations; 
     82    bool             m_isBusManagerCapable; 
     83    fb_byte_t        m_cycleClkAcc; 
     84    fb_byte_t        m_maxRec; 
     85    unsigned short   m_nodeVendorId; 
     86    fb_byte_t        m_chipIdHi; 
     87    fb_quadlet_t     m_chipIdLow; 
    6388 
    6489    /* only used during parsing */ 
  • branches/libfreebob-downloader/src/libfreebobavc/ieee1394service.cpp

    r241 r271  
    2626 
    2727#include <iostream> 
    28  
    29 using namespace std; 
     28#include <iomanip> 
     29 
    3030 
    3131Ieee1394Service::Ieee1394Service() 
    3232    : m_handle( 0 ) 
    3333    , m_port( -1 ) 
    34 
     34    , m_verbose( false ) 
     35    , m_threadRunning( false ) 
     36
     37    pthread_mutex_init( &m_mutex, 0 ); 
    3538} 
    3639 
    3740Ieee1394Service::~Ieee1394Service() 
    3841{ 
    39     if (m_handle) { 
    40         raw1394_destroy_handle(m_handle); 
    41     } 
    42  
     42    stopRHThread(); 
     43 
     44    if ( m_handle ) { 
     45        raw1394_destroy_handle( m_handle ); 
     46    } 
     47    if ( m_resetHandle ) { 
     48        raw1394_destroy_handle( m_resetHandle ); 
     49    } 
    4350} 
    4451 
     
    4653Ieee1394Service::initialize( int port ) 
    4754{ 
     55    using namespace std; 
     56 
    4857    m_handle = raw1394_new_handle_on_port( port ); 
    4958    if ( !m_handle ) { 
     
    5766    } 
    5867 
     68    m_resetHandle = raw1394_new_handle_on_port( port ); 
     69    if ( !m_handle ) { 
     70        if ( !errno ) { 
     71            cerr << "libraw1394 not compatible" << endl; 
     72        } else { 
     73            perror( "Ieee1394Service::initialize: Could not get 1394 handle" ); 
     74            cerr << "Is ieee1394 and raw1394 driver loaded?" << endl; 
     75        } 
     76        return false; 
     77    } 
     78 
    5979    m_port = port; 
     80 
     81    raw1394_set_userdata( m_handle, this ); 
     82    raw1394_set_userdata( m_resetHandle, this ); 
     83    raw1394_set_bus_reset_handler( m_resetHandle, 
     84                                   this->resetHandlerLowLevel ); 
     85    startRHThread(); 
     86 
    6087    return true; 
    6188} 
     
    7097Ieee1394Service::read( fb_nodeid_t nodeId, 
    7198                       fb_nodeaddr_t addr, 
    72                        size_t size
     99                       size_t length
    73100                       fb_quadlet_t* buffer ) 
    74101{ 
    75     return raw1394_read( m_handle, nodeId, addr,  size,  buffer ) != 0; 
    76 
    77  
    78 bool 
    79 Ieee1394Service::write( fb_nodeid_t   nodeId, 
     102    using namespace std; 
     103    if ( raw1394_read( m_handle, nodeId, addr, length*4, buffer ) == 0 ) { 
     104 
     105        #ifdef DEBUG 
     106        if ( m_verbose ) { 
     107            cout << "read:  node 0x" << hex << nodeId <<", addr = 0x" 
     108                 << setfill( '0' ) << setw( 16 ) << addr 
     109                 << ", length = " << dec << length << " quadlets" << endl; 
     110            printBuffer( length, buffer ); 
     111        } 
     112        #endif 
     113 
     114        return true; 
     115    } else { 
     116        #ifdef DEBUG 
     117        if ( m_verbose ) { 
     118            cerr << "raw1394_read failed: node 0x" << hex << nodeId 
     119                 << ", addr 0x" << setfill( '0' ) << setw( 16 ) << addr 
     120                 << ", length = " << dec << length << " quadlets" << endl; 
     121        } 
     122        #endif 
     123 
     124        return false; 
     125    } 
     126
     127 
     128 
     129bool 
     130Ieee1394Service::read_quadlet( fb_nodeid_t nodeId, 
     131                               fb_nodeaddr_t addr, 
     132                               fb_quadlet_t* buffer ) 
     133
     134    return read( nodeId,  addr, sizeof( *buffer )/4, buffer ); 
     135
     136 
     137bool 
     138Ieee1394Service::read_octlet( fb_nodeid_t nodeId, 
     139                              fb_nodeaddr_t addr, 
     140                              fb_octlet_t* buffer ) 
     141
     142    return read( nodeId, addr, sizeof( *buffer )/4, 
     143                 reinterpret_cast<fb_quadlet_t*>( buffer ) ); 
     144
     145 
     146 
     147bool 
     148Ieee1394Service::write( fb_nodeid_t nodeId, 
    80149                        fb_nodeaddr_t addr, 
    81                         size_t        length, 
    82                         fb_quadlet_t  *data ) 
    83 
    84     return raw1394_write( m_handle, nodeId, addr, length, data ) != 0; 
     150                        size_t length, 
     151                        fb_quadlet_t* data ) 
     152
     153    using namespace std; 
     154 
     155    #ifdef DEBUG 
     156    if ( m_verbose ) { 
     157        cout << "write: node 0x" << hex << nodeId << ", addr = 0x" 
     158             << setfill( '0' ) << setw( 16 ) << addr 
     159             << ", length = " << dec << length << " quadlets" << endl; 
     160        printBuffer( length, data ); 
     161    } 
     162    #endif 
     163 
     164    return raw1394_write( m_handle, nodeId, addr, length*4, data ) == 0; 
     165
     166 
     167 
     168bool 
     169Ieee1394Service::write_quadlet( fb_nodeid_t nodeId, 
     170                                fb_nodeaddr_t addr, 
     171                                fb_quadlet_t data ) 
     172
     173    return write( nodeId, addr, sizeof( data )/4, &data ); 
     174
     175 
     176bool 
     177Ieee1394Service::write_octlet( fb_nodeid_t nodeId, 
     178                               fb_nodeaddr_t addr, 
     179                               fb_octlet_t data ) 
     180
     181    return write( nodeId, addr, sizeof( data )/4, 
     182                  reinterpret_cast<fb_quadlet_t*>( &data ) ); 
    85183} 
    86184 
     
    117215    return true; 
    118216} 
     217 
     218void 
     219Ieee1394Service::setVerbose( bool isVerbose ) 
     220{ 
     221    m_verbose = isVerbose; 
     222} 
     223 
     224void 
     225Ieee1394Service::printBuffer( size_t length, fb_quadlet_t* buffer ) const 
     226{ 
     227    using namespace std; 
     228 
     229    for ( unsigned int i=0; i < length; ++i ) { 
     230        if ( ( i % 4 ) == 0 ) { 
     231            if ( i > 0 ) { 
     232                cout << endl; 
     233            } 
     234            cout << setfill( ' ' ) << setw( 4 ) << i*4 << ": "; 
     235        } 
     236        cout << setfill( '0' ) << setw( 8 ) << hex << buffer[i] << " "; 
     237    } 
     238    cout << endl; 
     239} 
     240 
     241int 
     242Ieee1394Service::resetHandlerLowLevel( raw1394handle_t handle, 
     243                                       unsigned int generation ) 
     244{ 
     245    raw1394_update_generation ( handle, generation ); 
     246    Ieee1394Service* instance 
     247        = (Ieee1394Service*) raw1394_get_userdata( handle ); 
     248    instance->resetHandler( generation ); 
     249 
     250    return 0; 
     251} 
     252 
     253bool 
     254Ieee1394Service::resetHandler( unsigned int generation ) 
     255{ 
     256    m_generation = generation; 
     257 
     258    for ( reset_handler_vec_t::iterator it = m_busResetHandlers.begin(); 
     259          it != m_busResetHandlers.end(); 
     260          ++it ) 
     261    { 
     262        Functor* func = *it; 
     263        ( *func )(); 
     264    } 
     265 
     266    return true; 
     267} 
     268 
     269bool 
     270Ieee1394Service::startRHThread() 
     271{ 
     272    if ( m_threadRunning ) { 
     273        return true; 
     274    } 
     275    pthread_mutex_lock( &m_mutex ); 
     276    pthread_create( &m_thread, 0, rHThread, this ); 
     277    pthread_mutex_unlock( &m_mutex ); 
     278    m_threadRunning = true; 
     279 
     280    return true; 
     281} 
     282 
     283void 
     284Ieee1394Service::stopRHThread() 
     285{ 
     286    if ( m_threadRunning ) { 
     287        pthread_mutex_lock (&m_mutex); 
     288        pthread_cancel (m_thread); 
     289        pthread_join (m_thread, 0); 
     290        pthread_mutex_unlock (&m_mutex); 
     291        m_threadRunning = false; 
     292    } 
     293} 
     294 
     295void* 
     296Ieee1394Service::rHThread( void* arg ) 
     297{ 
     298    Ieee1394Service* pIeee1394Service = (Ieee1394Service*) arg; 
     299 
     300    while (true) { 
     301        raw1394_loop_iterate (pIeee1394Service->m_resetHandle); 
     302        pthread_testcancel (); 
     303    } 
     304 
     305    return 0; 
     306} 
     307 
     308bool 
     309Ieee1394Service::addBusResetHandler( Functor* functor ) 
     310{ 
     311    m_busResetHandlers.push_back( functor ); 
     312    return true; 
     313} 
     314 
     315bool 
     316Ieee1394Service::remBusResetHandler( Functor* functor ) 
     317{ 
     318    for ( reset_handler_vec_t::iterator it = m_busResetHandlers.begin(); 
     319          it != m_busResetHandlers.end(); 
     320          ++it ) 
     321    { 
     322        if ( *it == functor ) { 
     323            m_busResetHandlers.erase( it ); 
     324            return true; 
     325        } 
     326    } 
     327    return false; 
     328} 
  • branches/libfreebob-downloader/src/libfreebobavc/ieee1394service.h

    r241 r271  
    11/* Ieee1394Service.cpp 
    2  * Copyright (C) 2005 by Daniel Wagner 
     2 * Copyright (C) 2005,06 by Daniel Wagner 
    33 * 
    44 * This file is part of FreeBoB. 
     
    2323 
    2424#include "fbtypes.h" 
     25#include "threads.h" 
    2526 
    2627#include <libraw1394/raw1394.h> 
     28#include <pthread.h> 
     29 
     30#include <vector> 
    2731 
    2832class Ieee1394Service{ 
     
    4953   /** 
    5054    * read - send async read request to a node and wait for response. 
    51     * @node: target node 
     55    * @node: target node (\XXX needs 0xffc0 stuff) 
    5256    * @addr: address to read from 
    5357    * @length: amount of data to read in quadlets 
     
    5660    * This does the complete transaction and will return when it's finished. 
    5761    * 
    58     * Returns: truee on success or false on failure (sets errno) 
     62    * Returns: true on success or false on failure (sets errno) 
    5963    */ 
    6064    bool read( fb_nodeid_t nodeId, 
    6165               fb_nodeaddr_t addr, 
    62                size_t size
     66               size_t length
    6367               fb_quadlet_t* buffer ); 
    6468 
    65    /** 
     69    bool read_quadlet( fb_nodeid_t nodeId, 
     70                       fb_nodeaddr_t addr, 
     71                       fb_quadlet_t* buffer ); 
     72 
     73    bool read_octlet( fb_nodeid_t nodeId, 
     74                      fb_nodeaddr_t addr, 
     75                      fb_octlet_t* buffer ); 
     76 
     77    /** 
    6678    * write - send async write request to a node and wait for response. 
    67     * @node: target node 
     79    * @node: target node (\XXX needs 0xffc0 stuff) 
    6880    * @addr: address to write to 
    6981    * @length: amount of data to write in quadlets 
     
    7486    * Returns: true on success or false on failure (sets errno) 
    7587    */ 
    76     bool write( fb_nodeid_t   nodeId, 
     88    bool write( fb_nodeid_t nodeId, 
    7789                fb_nodeaddr_t addr, 
    78                 size_t        length, 
    79                 fb_quadlet_t  *data ); 
     90                size_t length, 
     91                fb_quadlet_t* data ); 
    8092 
     93    bool write_quadlet( fb_nodeid_t nodeId, 
     94                        fb_nodeaddr_t addr, 
     95                        fb_quadlet_t data ); 
     96 
     97    bool write_octlet(  fb_nodeid_t nodeId, 
     98                        fb_nodeaddr_t addr, 
     99                        fb_octlet_t data ); 
    81100 
    82101    fb_quadlet_t* transactionBlock( fb_nodeid_t nodeId, 
     
    86105 
    87106    bool transactionBlockClose(); 
    88      
     107 
     108 
     109    void setVerbose( bool isVerbose ); 
     110 
     111 
     112    bool addBusResetHandler( Functor* functor ); 
     113    bool remBusResetHandler( Functor* functor ); 
     114 
    89115private: 
     116 
     117    bool startRHThread(); 
     118    void stopRHThread(); 
     119    static void* rHThread( void* arg ); 
     120 
     121    void printBuffer( size_t length, fb_quadlet_t* buffer ) const; 
     122 
     123    static int resetHandlerLowLevel( raw1394handle_t handle, 
     124                                     unsigned int generation ); 
     125    bool resetHandler( unsigned int generation ); 
     126 
    90127    raw1394handle_t m_handle; 
     128    raw1394handle_t m_resetHandle; 
    91129    int             m_port; 
     130    bool            m_verbose; 
     131    unsigned int    m_generation; 
     132 
     133    pthread_t       m_thread; 
     134    pthread_mutex_t m_mutex; 
     135    bool            m_threadRunning; 
     136 
     137    typedef std::vector< Functor* > reset_handler_vec_t; 
     138    reset_handler_vec_t m_busResetHandlers; 
    92139}; 
    93140 
  • branches/libfreebob-downloader/src/libfreebobavc/serialize.cpp

    r241 r271  
    9797    bool result = false; 
    9898    if ( isCurPosValid() ) { 
    99         *value = *m_curPos
     99        *value = *( ( quadlet_t* )m_curPos )
    100100        m_curPos += sizeof( quadlet_t ); 
    101101        result = true; 
  • branches/libfreebob-downloader/src/Makefile.am

    r259 r271  
    3535        freebob.cpp                                     \ 
    3636        xmlparser.c                                     \ 
     37        threads.h                                       \ 
    3738        bebob/bebob_avdevice.h                          \ 
    3839        bebob/bebob_avdevice.cpp                        \ 
     
    4546        bebob/bebob_functionblock.h                     \ 
    4647        bebob/bebob_functionblock.cpp                   \ 
     48        bebob/bebob_dl_mgr.h                            \ 
     49        bebob/bebob_dl_mgr.cpp                          \ 
     50        bebob/bebob_dl_codes.h                          \ 
     51        bebob/bebob_dl_codes.cpp                        \ 
     52        bebob/bebob_dl_bcd.h                            \ 
     53        bebob/bebob_dl_bcd.cpp                          \ 
    4754        bebob_light/bebob_light_avdevice.h              \ 
    4855        bebob_light/bebob_light_avdevice.cpp            \ 
     
    101108 
    102109 
     110bin_PROGRAMS = freebob_downloader 
     111 
     112freebob_downloader_SOURCES =    \ 
     113        freebob-downloader.cpp 
     114freebob_downloader_LDADD =      \ 
     115        libfreebob.la           \ 
     116        $(LIBRAW1394_LIBS)      \ 
     117        $(LIBIEC61883_LIBS)     \ 
     118        $(LIBAVC1394_LIBS)      \ 
     119        -lpthread