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

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

- Remove some obsolete support files and dirs

- Clean up the license statements in the source files. Everything is

GPL version 3 now.

- Add license and copyright notices to scons scripts

- Clean up some other text files

  • 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 program is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation, either version 3 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
23  *
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.