root/trunk/libffado/src/libieee1394/configrom.cpp

Revision 739, 19.5 kB (checked in by ppalmers, 13 years ago)

- Adapt the ffado external API (upgrade to v3)

NEEDS NEW JACK BACKEND

- simplify FFADODevice constructor even more
- implement first framework support for supporting multiple adapters.

currently all firewire adapters are scanned for supported devices unless specified otherwise
however attaching devices to separate adapters is not supported. using multiple adapters at
that are connected together might work.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1 /*
2  * Copyright (C) 2005-2007 by Daniel Wagner
3  * Copyright (C) 2005-2007 by Jonathan Woithe
4  * Copyright (C) 2005-2007 by Pieter Palmers
5  *
6  * This file is part of FFADO
7  * FFADO = Free Firewire (pro-)audio drivers for linux
8  *
9  * FFADO is based upon FreeBoB
10  *
11  * This library is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License version 2.1, as published by the Free Software Foundation;
14  *
15  * This library is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with this library; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
23  * MA 02110-1301 USA
24  */
25
26 #include "configrom.h"
27 #include "ieee1394service.h"
28
29 #include <stdio.h>
30 #include <string.h>
31
32 #include <iostream>
33 #include <iomanip>
34
35 using namespace std;
36
37 IMPL_DEBUG_MODULE( ConfigRom, ConfigRom, DEBUG_LEVEL_NORMAL );
38
39 static int busRead( struct csr1212_csr* csr,
40                     u_int64_t addr,
41                     u_int16_t length,
42                     void* buffer,
43                     void* private_data );
44
45 static int getMaxRom( u_int32_t* bus_info_data,
46                       void* private_data );
47
48 static struct csr1212_bus_ops configrom_csr1212_ops = {
49     busRead,
50     0,
51     0,
52     getMaxRom
53 };
54
55 struct config_csr_info {
56     Ieee1394Service* service;
57     fb_nodeid_t      nodeId;
58 };
59
60 //-------------------------------------------------------------
61
62 ConfigRom::ConfigRom( Ieee1394Service& ieee1394service, fb_nodeid_t nodeId )
63     : Control::Element("ConfigRom")
64     , m_1394Service( ieee1394service )
65     , m_nodeId( nodeId )
66     , m_avcDevice( false ) // FIXME: this does not seem veryu
67     , m_guid( 0 )
68     , m_vendorName( "" )
69     , m_modelName( "" )
70     , m_vendorId( 0 )
71     , m_modelId( 0 )
72     , m_unit_specifier_id( 0 )
73     , m_unit_version( 0 )
74     , m_isIsoResourceManager( false )
75     , m_isCycleMasterCapable( false )
76     , m_isSupportIsoOperations( false )
77     , m_isBusManagerCapable( false )
78     , m_cycleClkAcc( 0 )
79     , m_maxRec( 0 )
80     , m_nodeVendorId( 0 )
81     , m_chipIdHi( 0 )
82     , m_chipIdLow( 0 )
83     , m_vendorNameKv( 0 )
84     , m_modelNameKv( 0 )
85     , m_csr( 0 )
86 {
87 }
88
89 ConfigRom::ConfigRom()
90     : Control::Element("ConfigRom")
91     , m_1394Service( *(new Ieee1394Service()) )
92     , m_nodeId( -1 )
93     , m_avcDevice( false ) // FIXME: this does not seem veryu
94     , m_guid( 0 )
95     , m_vendorName( "" )
96     , m_modelName( "" )
97     , m_vendorId( 0 )
98     , m_modelId( 0 )
99     , m_unit_specifier_id( 0 )
100     , m_unit_version( 0 )
101     , m_isIsoResourceManager( false )
102     , m_isCycleMasterCapable( false )
103     , m_isSupportIsoOperations( false )
104     , m_isBusManagerCapable( false )
105     , m_cycleClkAcc( 0 )
106     , m_maxRec( 0 )
107     , m_nodeVendorId( 0 )
108     , m_chipIdHi( 0 )
109     , m_chipIdLow( 0 )
110     , m_vendorNameKv( 0 )
111     , m_modelNameKv( 0 )
112     , m_csr( 0 )
113 {
114 }
115
116 Ieee1394Service&
117 ConfigRom::get1394Service()
118 {
119     return m_1394Service;
120 }
121
122 bool
123 ConfigRom::operator == ( const ConfigRom& rhs )
124 {
125     return m_guid == rhs.m_guid;
126 }
127
128 bool
129 ConfigRom::compareGUID( const ConfigRom& a, const ConfigRom& b ) {
130     return a.getGuid() > b.getGuid();
131 }
132
133 bool
134 ConfigRom::initialize()
135 {
136      struct config_csr_info csr_info;
137      csr_info.service = &m_1394Service;
138      csr_info.nodeId = 0xffc0 | m_nodeId;
139
140      m_csr = csr1212_create_csr( &configrom_csr1212_ops,
141                                  5 * sizeof(fb_quadlet_t),   // XXX Why 5 ?!?
142                                  &csr_info );
143     if (!m_csr || csr1212_parse_csr( m_csr ) != CSR1212_SUCCESS) {
144         debugError( "Could not parse config rom of node %d on port %d\n", m_nodeId, m_1394Service.getPort() );
145         if (m_csr) {
146             csr1212_destroy_csr(m_csr);
147             m_csr = 0;
148         }
149         return false;
150     }
151
152     // Process Bus_Info_Block
153     m_isIsoResourceManager = CSR1212_BE32_TO_CPU(m_csr->bus_info_data[2] ) >> 31;
154     m_isCycleMasterCapable = ( CSR1212_BE32_TO_CPU(m_csr->bus_info_data[2] ) >> 30 ) & 0x1;
155     m_isSupportIsoOperations = ( CSR1212_BE32_TO_CPU(m_csr->bus_info_data[2] ) >> 29 ) & 0x1;
156     m_isBusManagerCapable = ( CSR1212_BE32_TO_CPU(m_csr->bus_info_data[2] ) >> 28 ) & 0x1;
157     m_cycleClkAcc = ( CSR1212_BE32_TO_CPU(m_csr->bus_info_data[2] ) >> 16 ) & 0xff;
158     m_maxRec = ( CSR1212_BE32_TO_CPU( m_csr->bus_info_data[2] ) >> 12 ) & 0xf;
159     m_nodeVendorId = ( CSR1212_BE32_TO_CPU( m_csr->bus_info_data[3] ) >> 8 );
160     m_chipIdHi = ( CSR1212_BE32_TO_CPU( m_csr->bus_info_data[3] ) ) & 0xff;
161     m_chipIdLow = CSR1212_BE32_TO_CPU( m_csr->bus_info_data[4] );
162
163     // Process Root Directory
164     processRootDirectory(m_csr);
165
166     if ( m_vendorNameKv ) {
167         int len = ( m_vendorNameKv->value.leaf.len - 2) * sizeof( quadlet_t );
168         char* buf = new char[len+2];
169         memcpy( buf,
170                 ( void* )CSR1212_TEXTUAL_DESCRIPTOR_LEAF_DATA( m_vendorNameKv ),
171                 len );
172
173     while ((buf + len - 1) == '\0') {
174             len--;
175         }
176         // \todo XXX seems a bit strage to do this but the nodemgr.c code does
177         // it. try to figure out why this is needed (or not)
178     buf[len++] = ' ';
179     buf[len] = '\0';
180
181
182         debugOutput( DEBUG_LEVEL_VERBOSE, "Vendor name: '%s'\n", buf );
183         m_vendorName = buf;
184         delete[] buf;
185     }
186     if ( m_modelNameKv ) {
187         int len = ( m_modelNameKv->value.leaf.len - 2) * sizeof( quadlet_t );
188         char* buf = new char[len+2];
189         memcpy( buf,
190                 ( void* )CSR1212_TEXTUAL_DESCRIPTOR_LEAF_DATA( m_modelNameKv ),
191                 len );
192     while ((buf + len - 1) == '\0') {
193             len--;
194         }
195         // \todo XXX for edirol fa-66 it seems somehow broken. see above
196         // todo as well.
197     buf[len++] = ' ';
198     buf[len] = '\0';
199
200         debugOutput( DEBUG_LEVEL_VERBOSE, "Model name: '%s'\n", buf);
201         m_modelName = buf;
202         delete[] buf;
203     }
204
205     m_guid = ((u_int64_t)CSR1212_BE32_TO_CPU(m_csr->bus_info_data[3]) << 32)
206              | CSR1212_BE32_TO_CPU(m_csr->bus_info_data[4]);
207
208     if ( m_vendorNameKv ) {
209         csr1212_release_keyval( m_vendorNameKv );
210         m_vendorNameKv = 0;
211     }
212     if ( m_modelNameKv ) {
213         csr1212_release_keyval( m_modelNameKv );
214         m_modelNameKv = 0;
215     }
216     if ( m_csr ) {
217         csr1212_destroy_csr(m_csr);
218         m_csr = 0;
219     }
220     return true;
221 }
222
223 static int
224 busRead( struct csr1212_csr* csr,
225          u_int64_t addr,
226          u_int16_t length,
227          void* buffer,
228          void* private_data )
229 {
230     struct config_csr_info* csr_info = (struct config_csr_info*) private_data;
231
232     int nb_retries = 5;
233
234     while ( nb_retries--
235             && !csr_info->service->read( csr_info->nodeId,
236                                          addr,
237                                          (size_t)length/4,
238                                          ( quadlet_t* )buffer)  )
239     {// failed, retry
240     }
241
242     if (nb_retries > -1) return 0; // success
243     else return -1; // failure
244 }
245
246 static int
247 getMaxRom( u_int32_t* bus_info_data,
248            void* /*private_data*/)
249 {
250     return (CSR1212_BE32_TO_CPU( bus_info_data[2] ) >> 8) & 0x3;
251 }
252
253
254 void
255 ConfigRom::processUnitDirectory( struct csr1212_csr* csr,
256                                  struct csr1212_keyval* ud_kv,
257                                  unsigned int *id )
258 {
259     struct csr1212_dentry *dentry;
260     struct csr1212_keyval *kv;
261     unsigned int last_key_id = 0;
262
263     debugOutput( DEBUG_LEVEL_VERBOSE, "process unit directory:\n" );
264     csr1212_for_each_dir_entry(csr, kv, ud_kv, dentry) {
265     switch (kv->key.id) {
266         case CSR1212_KV_ID_VENDOR:
267         if (kv->key.type == CSR1212_KV_TYPE_IMMEDIATE) {
268                     debugOutput( DEBUG_LEVEL_VERBOSE,
269                                  "\tvendor_id = 0x%08x\n",
270                                  kv->value.immediate);
271                     m_vendorId = kv->value.immediate;
272         }
273         break;
274
275         case CSR1212_KV_ID_MODEL:
276                 debugOutput( DEBUG_LEVEL_VERBOSE,
277                              "\tmodel_id = 0x%08x\n",
278                              kv->value.immediate);
279                 m_modelId = kv->value.immediate;
280         break;
281
282         case CSR1212_KV_ID_SPECIFIER_ID:
283                 debugOutput( DEBUG_LEVEL_VERBOSE,
284                              "\tspecifier_id = 0x%08x\n",
285                              kv->value.immediate);
286                 m_unit_specifier_id = kv->value.immediate;
287         break;
288
289         case CSR1212_KV_ID_VERSION:
290                 debugOutput( DEBUG_LEVEL_VERBOSE,
291                              "\tversion = 0x%08x\n",
292                              kv->value.immediate);
293                 m_unit_version = kv->value.immediate;
294                 if ( m_unit_specifier_id == 0x0000a02d ) // XXX
295                 {
296                     m_avcDevice = true; // FIXME: disable this check for the moment
297                     if ( kv->value.immediate == 0x14001 ) {
298                         m_avcDevice = true;
299                     }
300                 }
301         break;
302
303         case CSR1212_KV_ID_DESCRIPTOR:
304         if (kv->key.type == CSR1212_KV_TYPE_LEAF &&
305             CSR1212_DESCRIPTOR_LEAF_TYPE(kv) == 0 &&
306             CSR1212_DESCRIPTOR_LEAF_SPECIFIER_ID(kv) == 0 &&
307             CSR1212_TEXTUAL_DESCRIPTOR_LEAF_WIDTH(kv) == 0 &&
308             CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET(kv) == 0 &&
309             CSR1212_TEXTUAL_DESCRIPTOR_LEAF_LANGUAGE(kv) == 0)
310         {
311             switch (last_key_id) {
312             case CSR1212_KV_ID_VENDOR:
313                 csr1212_keep_keyval(kv);
314                             m_vendorNameKv = kv;
315                 break;
316
317             case CSR1212_KV_ID_MODEL:
318                             m_modelNameKv = kv;
319                 csr1212_keep_keyval(kv);
320                 break;
321
322             }
323         } /* else if (kv->key.type == CSR1212_KV_TYPE_DIRECTORY) ... */
324         break;
325
326         case CSR1212_KV_ID_DEPENDENT_INFO:
327         if (kv->key.type == CSR1212_KV_TYPE_DIRECTORY) {
328             /* This should really be done in SBP2 as this is
329              * doing SBP2 specific parsing. */
330             processUnitDirectory(csr, kv, id);
331         }
332
333         break;
334
335         default:
336         break;
337     }
338     last_key_id = kv->key.id;
339     }
340 }
341
342 void
343 ConfigRom::processRootDirectory(struct csr1212_csr* csr)
344 {
345     unsigned int ud_id = 0;
346     struct csr1212_dentry *dentry;
347     struct csr1212_keyval *kv;
348     unsigned int last_key_id = 0;
349
350     csr1212_for_each_dir_entry(csr, kv, csr->root_kv, dentry) {
351     switch (kv->key.id) {
352         case CSR1212_KV_ID_VENDOR:
353                 debugOutput( DEBUG_LEVEL_VERBOSE,
354                              "vendor id = 0x%08x\n", kv->value.immediate);
355         break;
356
357         case CSR1212_KV_ID_NODE_CAPABILITIES:
358                 debugOutput( DEBUG_LEVEL_VERBOSE,
359                              "capabilities = 0x%08x\n", kv->value.immediate);
360         break;
361
362         case CSR1212_KV_ID_UNIT:
363         processUnitDirectory(csr, kv, &ud_id);
364         break;
365
366         case CSR1212_KV_ID_DESCRIPTOR:
367         if (last_key_id == CSR1212_KV_ID_VENDOR) {
368             if (kv->key.type == CSR1212_KV_TYPE_LEAF &&
369             CSR1212_DESCRIPTOR_LEAF_TYPE(kv) == 0 &&
370             CSR1212_DESCRIPTOR_LEAF_SPECIFIER_ID(kv) == 0 &&
371             CSR1212_TEXTUAL_DESCRIPTOR_LEAF_WIDTH(kv) == 0 &&
372             CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET(kv) == 0 &&
373             CSR1212_TEXTUAL_DESCRIPTOR_LEAF_LANGUAGE(kv) == 0)
374                     {
375                         m_vendorNameKv = kv;
376             csr1212_keep_keyval(kv);
377             }
378         }
379         break;
380     }
381     last_key_id = kv->key.id;
382     }
383
384 }
385
386 const fb_nodeid_t
387 ConfigRom::getNodeId() const
388 {
389     return m_nodeId;
390 }
391
392 const fb_octlet_t
393 ConfigRom::getGuid() const
394 {
395     return m_guid;
396 }
397
398 const Glib::ustring
399 ConfigRom::getGuidString() const
400 {
401     char* buf;
402     asprintf( &buf, "%08x%08x",
403               ( unsigned int ) ( getGuid() >> 32 ),
404               ( unsigned int ) ( getGuid() & 0xffffffff ) );
405     Glib::ustring result = buf;
406     free( buf );
407     return result;
408 }
409  
410 const Glib::ustring
411 ConfigRom::getModelName() const
412 {
413     return m_modelName;
414 }
415
416 const Glib::ustring
417 ConfigRom::getVendorName() const
418 {
419     return m_vendorName;
420 }
421
422 const unsigned int
423 ConfigRom::getModelId() const
424 {
425     return m_modelId;
426 }
427
428 const unsigned int
429 ConfigRom::getVendorId() const
430 {
431     return m_vendorId;
432 }
433
434 const unsigned int
435 ConfigRom::getUnitSpecifierId() const
436 {
437     return m_unit_specifier_id;
438 }
439
440 const unsigned int
441 ConfigRom::getUnitVersion() const
442 {
443     return m_unit_version;
444 }
445
446 bool
447 ConfigRom::updatedNodeId()
448 {
449     debugOutput( DEBUG_LEVEL_VERBOSE,
450                  "Checking for updated node id for device with GUID 0x%016llX...\n",
451                  getGuid());
452
453     struct csr1212_csr* csr = NULL;
454     for ( fb_nodeid_t nodeId = 0;
455           nodeId < m_1394Service.getNodeCount();
456           ++nodeId )
457     {
458         struct config_csr_info csr_info;
459         csr_info.service = &m_1394Service;
460         csr_info.nodeId = 0xffc0 | nodeId;
461         debugOutput( DEBUG_LEVEL_VERBOSE, "Looking at node %d...\n", nodeId);
462
463         csr = csr1212_create_csr( &configrom_csr1212_ops,
464                                   5 * sizeof(fb_quadlet_t),   // XXX Why 5 ?!?
465                                   &csr_info );
466
467         if (!csr || csr1212_parse_csr( csr ) != CSR1212_SUCCESS) {
468             debugWarning( "Failed to get/parse CSR\n");
469             if (csr) {
470                 csr1212_destroy_csr(csr);
471                 csr = NULL;
472             }
473             continue;
474         }
475
476         octlet_t guid =
477             ((u_int64_t)CSR1212_BE32_TO_CPU(csr->bus_info_data[3]) << 32)
478             | CSR1212_BE32_TO_CPU(csr->bus_info_data[4]);
479
480         debugOutput( DEBUG_LEVEL_VERBOSE,
481                         " Node has GUID 0x%016llX\n",
482                         guid);
483
484         if ( guid == getGuid() ) {
485             debugOutput( DEBUG_LEVEL_VERBOSE, "GUID matches ours\n");
486             if ( nodeId != getNodeId() ) {
487                 debugOutput( DEBUG_LEVEL_VERBOSE,
488                              "Device with GUID 0x%016llX changed node id "
489                              "from %d to %d\n",
490                              getGuid(),
491                              getNodeId(),
492                              nodeId );
493                 m_nodeId = nodeId;
494             } else {
495                 debugOutput( DEBUG_LEVEL_VERBOSE,
496                              "Device with GUID 0x%016llX kept node id %d\n",
497                              getGuid(),
498                              getNodeId());
499             }
500             if (csr) {
501                 csr1212_destroy_csr(csr);
502                 csr = NULL;
503             }
504             return true;
505         }
506     }
507
508     if (csr) {
509         csr1212_destroy_csr(csr);
510     }
511
512     debugOutput( DEBUG_LEVEL_NORMAL,
513                  "Device with GUID 0x%08x%08x could not be found on "
514                  "the bus anymore (removed?)\n",
515                  m_guid >> 32,
516                  m_guid & 0xffffffff );
517     return false;
518 }
519
520 void
521 ConfigRom::printConfigRom() const
522 {
523     using namespace std;
524     debugOutput(DEBUG_LEVEL_NORMAL, "Config ROM\n" );
525     debugOutput(DEBUG_LEVEL_NORMAL, "\tCurrent Node Id:\t%d\n",       getNodeId() );
526     debugOutput(DEBUG_LEVEL_NORMAL, "\tGUID:\t\t\t0x%016llX\n",       getGuid());
527     debugOutput(DEBUG_LEVEL_NORMAL, "\tVendor Name:\t\t%s\n",         getVendorName().c_str() );
528     debugOutput(DEBUG_LEVEL_NORMAL, "\tModel Name:\t\t%s\n",          getModelName().c_str() );
529     debugOutput(DEBUG_LEVEL_NORMAL, "\tNode Vendor ID:\t\t0x%06x\n",  getNodeVendorId() );
530     debugOutput(DEBUG_LEVEL_NORMAL, "\tModel Id:\t\t0x%08x\n",        getModelId() );
531     debugOutput(DEBUG_LEVEL_NORMAL, "\tUnit Specifier ID:\t0x%06x\n",  getUnitSpecifierId() );
532     debugOutput(DEBUG_LEVEL_NORMAL, "\tUnit version:\t\t0x%08x\n",        getUnitVersion() );
533     debugOutput(DEBUG_LEVEL_NORMAL, "\tISO resource manager:\t%d\n",  isIsoResourseManager() );
534     debugOutput(DEBUG_LEVEL_NORMAL, "\tCycle master capable:\t%d\n",  isSupportsIsoOperations() );
535     debugOutput(DEBUG_LEVEL_NORMAL, "\tBus manager capable:\t%d\n",   isBusManagerCapable() );
536     debugOutput(DEBUG_LEVEL_NORMAL, "\tCycle clock accuracy:\t%d\n", getCycleClockAccurancy() );
537     debugOutput(DEBUG_LEVEL_NORMAL, "\tMax rec:\t\t%d (max asy payload: %d bytes)\n",
538             getMaxRec(), getAsyMaxPayload() );
539 }
540
541 unsigned short
542 ConfigRom::getAsyMaxPayload() const
543 {
544     // XXX use pow instead?
545     return 1 << ( m_maxRec + 1 );
546 }
547
548 bool
549 ConfigRom::serialize( Glib::ustring path, Util::IOSerialize& ser )
550 {
551     bool result;
552     result  = ser.write( path + "m_nodeId", m_nodeId );
553     result &= ser.write( path + "m_avcDevice",  m_avcDevice );
554     result &= ser.write( path + "m_guid", m_guid );
555     result &= ser.write( path + "m_vendorName", Glib::ustring( m_vendorName ) );
556     result &= ser.write( path + "m_modelName", Glib::ustring( m_modelName ) );
557     result &= ser.write( path + "m_vendorId", m_vendorId );
558     result &= ser.write( path + "m_modelId", m_modelId );
559     result &= ser.write( path + "m_unit_specifier_id", m_unit_specifier_id );
560     result &= ser.write( path + "m_unit_version",  m_unit_version );
561     result &= ser.write( path + "m_isIsoResourceManager", m_isIsoResourceManager );
562     result &= ser.write( path + "m_isCycleMasterCapable", m_isCycleMasterCapable );
563     result &= ser.write( path + "m_isSupportIsoOperations", m_isSupportIsoOperations );
564     result &= ser.write( path + "m_isBusManagerCapable", m_isBusManagerCapable );
565     result &= ser.write( path + "m_cycleClkAcc", m_cycleClkAcc );
566     result &= ser.write( path + "m_maxRec", m_maxRec );
567     result &= ser.write( path + "m_nodeVendorId", m_nodeVendorId );
568     result &= ser.write( path + "m_chipIdHi", m_chipIdHi );
569     result &= ser.write( path + "m_chipIdLow", m_chipIdLow );
570     return result;
571 }
572
573 ConfigRom*
574 ConfigRom::deserialize( Glib::ustring path, Util::IODeserialize& deser, Ieee1394Service& ieee1394Service )
575 {
576     ConfigRom* pConfigRom = new ConfigRom;
577     if ( !pConfigRom ) {
578         return 0;
579     }
580
581     pConfigRom->m_1394Service = ieee1394Service;
582
583     bool result;
584     result  = deser.read( path + "m_nodeId", pConfigRom->m_nodeId );
585     result &= deser.read( path + "m_avcDevice", pConfigRom->m_avcDevice );
586     result &= deser.read( path + "m_guid", pConfigRom->m_guid );
587     result &= deser.read( path + "m_vendorName", pConfigRom->m_vendorName );
588     result &= deser.read( path + "m_modelName", pConfigRom->m_modelName );
589     result &= deser.read( path + "m_vendorId", pConfigRom->m_vendorId );
590     result &= deser.read( path + "m_modelId", pConfigRom->m_modelId );
591     result &= deser.read( path + "m_unit_specifier_id", pConfigRom->m_unit_specifier_id );
592     result &= deser.read( path + "m_unit_version", pConfigRom->m_unit_version );
593     result &= deser.read( path + "m_isIsoResourceManager", pConfigRom->m_isIsoResourceManager );
594     result &= deser.read( path + "m_isCycleMasterCapable", pConfigRom->m_isCycleMasterCapable );
595     result &= deser.read( path + "m_isSupportIsoOperations", pConfigRom->m_isSupportIsoOperations );
596     result &= deser.read( path + "m_isBusManagerCapable", pConfigRom->m_isBusManagerCapable );
597     result &= deser.read( path + "m_cycleClkAcc", pConfigRom->m_cycleClkAcc );
598     result &= deser.read( path + "m_maxRec", pConfigRom->m_maxRec );
599     result &= deser.read( path + "m_nodeVendorId", pConfigRom->m_nodeVendorId );
600     result &= deser.read( path + "m_chipIdHi", pConfigRom->m_chipIdHi );
601     result &= deser.read( path + "m_chipIdLow", pConfigRom->m_chipIdLow );
602
603     if ( !result ) {
604         delete pConfigRom;
605         return 0;
606     }
607
608     return pConfigRom;
609 }
610
611 bool
612 ConfigRom::setNodeId( fb_nodeid_t nodeId )
613 {
614     m_nodeId = nodeId;
615     return true;
616 }
Note: See TracBrowser for help on using the browser.