root/trunk/libffado/src/bebob/bebob_dl_mgr.cpp

Revision 1131, 21.1 kB (checked in by ppalmers, 16 years ago)

implement endian fixes (thx Heikki Lindholm)
switch from network host order byteswap routines to size based swap routines to remove ambiguity in definition of "long"

Line 
1 /*
2  * Copyright (C) 2005-2008 by Daniel Wagner
3  *
4  * This file is part of FFADO
5  * FFADO = Free Firewire (pro-)audio drivers for linux
6  *
7  * FFADO is based upon FreeBoB
8  *
9  * This program is free software: you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation, either version 2 of the License, or
12  * (at your option) version 3 of the License.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
21  *
22  */
23
24 #include "bebob_dl_mgr.h"
25 #include "bebob_dl_codes.h"
26 #include "bebob_dl_bcd.h"
27
28 #include "libieee1394/configrom.h"
29 #include "libieee1394/ieee1394service.h"
30
31 #include "libutil/cmd_serialize.h"
32 #include "libutil/Time.h"
33
34 #include <byteswap.h>
35
36 #include <cstdio>
37
38 namespace BeBoB {
39     enum {
40         AddrRegInfo    = 0xffffc8020000ULL,
41         AddrRegReq     = 0xffffc8021000ULL,
42         AddrRegReqBuf  = 0xffffc8021040ULL,
43         AddrRegResp    = 0xffffc8029000ULL,
44         AddrRegRespBuf = 0xffffc8029040ULL,
45     };
46
47     enum {
48         RegInfoManufactorIdOffset =      0x00,
49         RegInfoProtocolVersionOffset =   0x08,
50         RegInfoBootloaderVersionOffset = 0x0c,
51         RegInfoGUID =                    0x10,
52         RegInfoHardwareModelId =         0x18,
53         RegInfoHardwareRevision =        0x1c,
54         RegInfoSoftwareDate =            0x20,
55         RegInfoSoftwareTime =            0x28,
56         RegInfoSoftwareId =              0x30,
57         RegInfoSoftwareVersion =         0x34,
58         RegInfoBaseAddress =             0x38,
59         RegInfoMaxImageLen =             0x3c,
60         RegInfoBootloaderDate =          0x40,
61         RegInfoBootloaderTime =          0x48,
62         RegInfoDebuggerDate =            0x50,
63         RegInfoDebuggerTime =            0x58,
64         RegInfoDebuggerId =              0x60,
65         RegInfoDebuggerVersion =         0x64
66     };
67
68     enum {
69         MaxRetries = 10,
70     };
71
72     IMPL_DEBUG_MODULE( BootloaderManager, BootloaderManager, DEBUG_LEVEL_NORMAL );
73 }
74
75 BeBoB::BootloaderManager::BootloaderManager(Ieee1394Service& ieee1349service,
76                                             fb_nodeid_t nodeId )
77     : m_ieee1394service( &ieee1349service )
78     , m_protocolVersion( eBPV_Unknown )
79     , m_isAppRunning( false )
80     , m_forceEnabled( false )
81     , m_bStartBootloader( true )
82 {
83     memset( &m_cachedInfoRegs, 0, sizeof( m_cachedInfoRegs ) );
84
85     m_configRom = new ConfigRom( *m_ieee1394service, nodeId );
86     // XXX throw exception if initialize fails!
87     m_configRom->initialize();
88     if ( !cacheInfoRegisters() ) {
89         debugError( "BootloaderManager: could not cache info registers\n" );
90     }
91
92     switch(  m_cachedInfoRegs.m_protocolVersion ) {
93     case 1:
94         m_protocolVersion = eBPV_V1;
95         break;
96     case 3:
97         m_protocolVersion = eBPV_V3;
98         break;
99     default:
100         // exception?
101         break;
102     }
103
104     pthread_mutex_init( &m_mutex, 0 );
105     pthread_cond_init( &m_cond, 0 );
106
107     m_functor = new MemberFunctor0< BeBoB::BootloaderManager*,
108                 void (BeBoB::BootloaderManager::*)() >
109                 ( this, &BeBoB::BootloaderManager::busresetHandler, false );
110     m_ieee1394service->addBusResetHandler( m_functor );
111 }
112
113 BeBoB::BootloaderManager::~BootloaderManager()
114 {
115     m_ieee1394service->remBusResetHandler( m_functor );
116     delete( m_functor );
117
118     delete m_configRom;
119
120     pthread_cond_destroy( &m_cond );
121     pthread_mutex_destroy( &m_mutex );
122 }
123
124 bool
125 BeBoB::BootloaderManager::cacheInfoRegisters()
126 {
127     if ( !m_configRom->updatedNodeId() ) {
128         debugError( "cacheInfoRegisters: did not find device anymore\n" );
129         return false;
130     }
131
132     if ( !m_ieee1394service->read(
133              0xffc0 | m_configRom->getNodeId(),
134              AddrRegInfo,
135              sizeof( m_cachedInfoRegs )/4,
136              reinterpret_cast<fb_quadlet_t*>( &m_cachedInfoRegs ) ) )
137     {
138         return false;
139     }
140
141     if ( m_cachedInfoRegs.m_bootloaderVersion != 0x0 ) {
142         m_isAppRunning = false;
143     } else {
144         m_isAppRunning = true;
145     }
146
147     m_cachedInfoRegs.m_guid = ( m_cachedInfoRegs.m_guid >> 32 )
148                               | ( m_cachedInfoRegs.m_guid << 32 );
149
150     return true;
151 }
152
153 bool
154 BeBoB::BootloaderManager::cacheInfoRegisters( int retries )
155 {
156     for ( int i = 0; i < retries; ++i ) {
157         if ( cacheInfoRegisters() ) {
158             return true;
159         }
160         sleep( 1 );
161     }
162
163     return false;
164 }
165
166 void
167 BeBoB::BootloaderManager::printInfoRegisters()
168 {
169     using namespace std;
170
171     if ( !cacheInfoRegisters() ) {
172         debugError( "Could not read info registers\n" );
173         return;
174     }
175
176     printf( "Info Registers\n" );
177     printf( "\tManufactors Id:\t\t%s\n",
178             makeString( m_cachedInfoRegs.m_manId ).c_str() );
179     printf( "\tProtocol Version:\t0x%08x\n",
180             m_cachedInfoRegs.m_protocolVersion );
181     printf( "\tBootloader Version:\t0x%08x\n",
182             m_cachedInfoRegs.m_bootloaderVersion );
183     printf( "\tGUID:\t\t\t0x%08x%08x\n",
184             ( unsigned int )( m_cachedInfoRegs.m_guid >> 32 ),
185             ( unsigned int )( m_cachedInfoRegs.m_guid & 0xffffffff ) );
186     printf( "\tHardware Model ID:\t0x%08x\n",
187             m_cachedInfoRegs.m_hardwareModelId );
188     printf( "\tHardware Revision:\t0x%08x\n",
189             m_cachedInfoRegs.m_hardwareRevision );
190     if (  m_cachedInfoRegs.m_softwareDate
191           && m_cachedInfoRegs.m_softwareTime )
192     {
193         printf( "\tSoftware Date:\t\t%s, %s\n",
194                 makeDate( m_cachedInfoRegs.m_softwareDate ).c_str(),
195                 makeTime( m_cachedInfoRegs.m_softwareTime ).c_str() );
196     }
197     printf( "\tSoftware Id:\t\t0x%08x\n", m_cachedInfoRegs.m_softwareId );
198     printf( "\tSoftware Version:\t0x%08x\n",
199             m_cachedInfoRegs.m_softwareVersion );
200     printf( "\tBase Address:\t\t0x%08x\n", m_cachedInfoRegs.m_baseAddress );
201     printf( "\tMax. Image Len:\t\t0x%08x\n", m_cachedInfoRegs.m_maxImageLen );
202     if ( m_cachedInfoRegs.m_bootloaderDate
203          && m_cachedInfoRegs.m_bootloaderTime )
204     {
205         printf( "\tBootloader Date:\t%s, %s\n",
206                 makeDate( m_cachedInfoRegs.m_bootloaderDate ).c_str(),
207                 makeTime( m_cachedInfoRegs.m_bootloaderTime ).c_str() );
208     }
209     if ( m_cachedInfoRegs.m_debuggerDate
210          && m_cachedInfoRegs.m_debuggerTime )
211     {
212         printf( "\tDebugger Date:\t\t%s, %s\n",
213                 makeDate( m_cachedInfoRegs.m_debuggerDate ).c_str(),
214                 makeTime( m_cachedInfoRegs.m_debuggerTime ).c_str() );
215     }
216     printf( "\tDebugger Id:\t\t0x%08x\n", m_cachedInfoRegs.m_debuggerId );
217     printf( "\tDebugger Version:\t0x%08x\n",
218             m_cachedInfoRegs.m_debuggerVersion );
219 }
220
221 bool
222 BeBoB::BootloaderManager::downloadFirmware( std::string filename )
223 {
224     using namespace std;
225
226     printf( "parse BCD file\n" );
227     std::auto_ptr<BCD> bcd = std::auto_ptr<BCD>( new BCD( filename ) );
228     if ( !bcd.get() ) {
229         debugError( "downloadFirmware: Could not open or parse BCD '%s'\n",
230                     filename.c_str() );
231         return false;
232     }
233     if ( !bcd->parse() ) {
234         debugError( "downloadFirmware: BCD parsing failed\n" );
235         return false;
236     }
237
238     printf( "check firmware device compatibility... " );
239     if ( !m_forceEnabled ) {
240         if ( !checkDeviceCompatibility( *bcd ) ) {
241             printf( "failed.\n" );
242             return false;
243         }
244         printf( "ok\n" );
245     } else {
246         printf( "forced\n" );
247     }
248
249     if ( m_bStartBootloader ) {
250         printf( "prepare for download (start bootloader)\n" );
251         if ( !startBootloaderCmd() ) {
252             debugError( "downloadFirmware: Could not start bootloader\n" );
253             return false;
254         }
255     }
256
257     printf( "start downloading protocol for application image\n" );
258     if ( !downloadObject( *bcd, eOT_Application ) ) {
259         debugError( "downloadFirmware: Firmware download failed\n" );
260         return false;
261     }
262
263     printf( "start downloading protocol for CnE\n" );
264     if ( !downloadObject( *bcd, eOT_CnE ) ) {
265         debugError( "downloadFirmware: CnE download failed\n" );
266         return false;
267     }
268
269     printf( "setting CnE to factory default settings\n" );
270     if ( !initializeConfigToFactorySettingCmd() ) {
271         debugError( "downloadFirmware: Could not reinitalize CnE\n" );
272         return false;
273     }
274
275     printf( "start application\n" );
276     if ( !startApplicationCmd() ) {
277         debugError( "downloadFirmware: Could not restart application\n" );
278         return false;
279     }
280
281     return true;
282 }
283
284 bool
285 BeBoB::BootloaderManager::downloadCnE( std::string filename )
286 {
287     using namespace std;
288
289     printf( "parse BCD file\n" );
290     std::auto_ptr<BCD> bcd = std::auto_ptr<BCD>( new BCD( filename ) );
291     if ( !bcd.get() ) {
292         debugError( "downloadCnE: Could not open or parse BCD '%s'\n",
293                     filename.c_str() );
294         return false;
295     }
296     if ( !bcd->parse() ) {
297         debugError( "downloadCnE: BCD parsing failed\n" );
298         return false;
299     }
300
301     printf( "check firmware device compatibility... " );
302     if ( !m_forceEnabled ) {
303         if ( !checkDeviceCompatibility( *bcd ) ) {
304             printf( "failed.\n" );
305             return false;
306         }
307         printf( "ok\n" );
308     } else {
309         printf( "forced\n" );
310     }
311
312     if ( m_bStartBootloader ) {
313         printf( "prepare for download (start bootloader)\n" );
314         if ( !startBootloaderCmd() ) {
315             debugError( "downloadCnE: Could not start bootloader\n" );
316             return false;
317         }
318     }
319
320     printf( "start downloading protocol for CnE\n" );
321     if ( !downloadObject( *bcd, eOT_CnE ) ) {
322         debugError( "downloadCnE: CnE download failed\n" );
323         return false;
324     }
325
326     printf( "setting CnE to factory default settings\n" );
327     if ( !initializeConfigToFactorySettingCmd() ) {
328         debugError( "downloadFirmware: Could not reinitalize CnE\n" );
329         return false;
330     }
331
332     printf( "start application\n" );
333     if ( !startApplicationCmd() ) {
334         debugError( "downloadCnE: Could not restart application\n" );
335         return false;
336     }
337
338     return true;
339 }
340
341
342 bool
343 BeBoB::BootloaderManager::downloadObject( BCD& bcd, EObjectType eObject )
344 {
345     using namespace std;
346
347     CommandCodesDownloadStart::EObject eCCDSObject;
348     fb_quadlet_t baseAddress;
349     fb_quadlet_t imageLength;
350     fb_quadlet_t crc;
351     fb_quadlet_t offset;
352
353     switch ( eObject ) {
354     case eOT_Application:
355         eCCDSObject = CommandCodesDownloadStart::eO_Application;
356         baseAddress = bcd.getImageBaseAddress();
357         imageLength = bcd.getImageLength();
358         crc = bcd.getImageCRC();
359         offset = bcd.getImageOffset();
360         break;
361     case eOT_CnE:
362         eCCDSObject = CommandCodesDownloadStart::eO_Config;
363         baseAddress = 0;
364         imageLength = bcd.getCnELength();
365         crc = bcd.getCnECRC();
366         offset = bcd.getCnEOffset();
367         break;
368     default:
369         return false;
370     }
371
372     CommandCodesDownloadStart ccDStart ( m_protocolVersion, eCCDSObject );
373     ccDStart.setDate( bcd.getSoftwareDate() );
374     ccDStart.setTime( bcd.getSoftwareTime() );
375     ccDStart.setId( bcd.getSoftwareId() );
376     ccDStart.setVersion( bcd.getSoftwareVersion() );
377     ccDStart.setBaseAddress( baseAddress );
378     ccDStart.setLength( imageLength );
379     ccDStart.setCRC( crc );
380
381     if ( !writeRequest( ccDStart ) ) {
382         debugError( "downloadObject: start command write request failed\n" );
383         return false;
384     }
385
386     // bootloader erases the flash, have to wait until is ready
387     // to answer our next request
388     printf( "wait until flash ereasing has terminated\n" );
389     sleep( 30 );
390
391     if ( !readResponse( ccDStart ) ) {
392         debugError( "downloadObject: (start) command read request failed\n" );
393         return false;
394     }
395
396     if ( ccDStart.getMaxBlockSize() < 0 ) {
397         debugError( "downloadObject: (start) command reported error %d\n",
398                     ccDStart.getMaxBlockSize() );
399         return false;
400     }
401
402     unsigned int maxBlockSize = m_configRom->getAsyMaxPayload();
403     unsigned int i = 0;
404     fb_quadlet_t address = 0;
405     bool result = true;
406     int totalBytes = imageLength;
407     int downloadedBytes = 0;
408     while ( imageLength > 0 ) {
409         unsigned int blockSize = imageLength > maxBlockSize ?
410                         maxBlockSize  : imageLength;
411
412         fb_byte_t block[blockSize];
413         if ( !bcd.read( offset, block, blockSize ) ) {
414             result = false;
415             break;
416         }
417
418         if ( !get1394Serivce()->write(
419                  0xffc0 | getConfigRom()->getNodeId(),
420                  AddrRegReqBuf,
421                  ( blockSize + 3 ) / 4,
422                  reinterpret_cast<fb_quadlet_t*>( block ) ) )
423         {
424             debugError( "downloadObject: Could not write to node %d\n",
425                         getConfigRom()->getNodeId() );
426             return false;
427         }
428
429         CommandCodesDownloadBlock ccBlock( m_protocolVersion );
430         ccBlock.setSeqNumber( i );
431         ccBlock.setAddress( baseAddress + address );
432         ccBlock.setNumberBytes( blockSize );
433
434         if ( !writeRequest( ccBlock ) ) {
435             debugError( "downloadObject: (block) write request failed\n" );
436             result = false;
437             break;
438         }
439         SleepRelativeUsec( 100 );
440
441         if ( !readResponse( ccBlock ) ) {
442             debugError( "downloadObject: (block) read request failed\n" );
443             result = false;
444             break;
445         }
446
447         if ( i != ccBlock.getRespSeqNumber() ) {
448             debugError( "downloadObject: (block) wrong sequence number "
449                         "reported. %d expected, %d reported\n",
450                         i, ccBlock.getRespSeqNumber() );
451             result = false;
452             break;
453         }
454         if ( ccBlock.getRespErrorCode() != 0 ) {
455             debugError( "downloadObject: (block) failed download with "
456                         "error code 0x%08x\n", ccBlock.getRespErrorCode() );
457             result = false;
458             break;
459         }
460
461         downloadedBytes += blockSize;
462         if ( ( i % 100 ) == 0 ) {
463            printf( "%10d/%d bytes downloaded\n",
464                    downloadedBytes, totalBytes );
465         }
466
467         imageLength -= blockSize;
468         address += blockSize;
469         offset += blockSize;
470         i++;
471     }
472     printf( "%10d/%d bytes downloaded\n",
473             downloadedBytes, totalBytes );
474
475     if ( !result ) {
476         debugError( "downloadObject: seqNumber = %d, "
477                     "address = 0%08x, offset = 0x%08x, "
478                     "restImageLength = 0x%08x\n",
479                     i, address, offset, imageLength );
480     }
481
482     CommandCodesDownloadEnd ccEnd( m_protocolVersion );
483     if ( !writeRequest( ccEnd ) ) {
484         debugError( "downloadObject: (end) command write failed\n" );
485     }
486
487     printf( "wait for transaction completion\n" );
488     sleep( 10 );
489
490     if ( !readResponse( ccEnd ) ) {
491         debugError( "downloadObject: (end) command read failed\n" );
492     }
493
494     if ( result ) {
495         if ( ccEnd.getRespIsValid() ) {
496             if ( ccEnd.getRespCrc32() == crc ) {
497                 debugOutput( DebugModule::eDL_Normal,
498                              "downloadObject: CRC match\n" );
499             } else {
500                 debugError( "downloadObject: CRC mismatch. 0x%08x expected, "
501                             "0x%08x reported",
502                             crc, ccEnd.getRespCrc32() );
503                 result = false;
504             }
505         } else {
506             debugError( "downloadObject: (end) object is not valid\n" );
507             result = false;
508         }
509     }
510     printf( "download protocol successfuly completed\n" );
511     return result;
512 }
513
514 bool
515 BeBoB::BootloaderManager::programGUID( fb_octlet_t guid )
516 {
517     if ( m_bStartBootloader ) {
518         if ( !startBootloaderCmd() ) {
519             debugError( "programGUID: Could not start bootloader\n" );
520             return false;
521         }
522     }
523
524     if ( !programGUIDCmd( guid ) ) {
525         debugError( "programGUID: Could not program guid\n" );
526         return false;
527     }
528
529     if ( !startApplicationCmd() ) {
530         debugError( "Could not restart application\n");
531         return false;
532     }
533
534     return true;
535 }
536
537 void
538 BeBoB::BootloaderManager::busresetHandler()
539 {
540     pthread_cond_signal( &m_cond );
541 }
542
543 void
544 BeBoB::BootloaderManager::waitForBusReset()
545 {
546     pthread_cond_wait( &m_cond, &m_mutex );
547 }
548
549 bool
550 BeBoB::BootloaderManager::writeRequest( CommandCodes& cmd )
551 {
552     unsigned char buf[ ( ( cmd.getMaxSize()+3 )/4 ) * 4 ];
553     memset( buf, 0, sizeof( buf ) );
554
555     Util::Cmd::BufferSerialize se( buf,  sizeof( buf ) );
556     if ( !cmd.serialize( se ) ) {
557         debugError( "writeRequest: Could not serialize command code %d\n",
558                     cmd.getCommandCode() );
559         return false;
560     }
561
562     if ( !get1394Serivce()->write(
563              0xffc0 | getConfigRom()->getNodeId(),
564              AddrRegReq,
565              sizeof( buf )/4,
566              reinterpret_cast<fb_quadlet_t*>( buf ) ) )
567     {
568         debugError( "writeRequest: Could not ARM write to node %d\n",
569                     getConfigRom()->getNodeId() );
570         return false;
571     }
572
573     return true;
574 }
575
576 bool
577 BeBoB::BootloaderManager::readResponse( CommandCodes& writeRequestCmd )
578 {
579     const size_t buf_length = 0x40;
580     unsigned char raw[buf_length];
581     if ( !get1394Serivce()->read(
582              0xffc0 | getConfigRom()->getNodeId(),
583              AddrRegResp,
584              writeRequestCmd.getRespSizeInQuadlets(),
585              reinterpret_cast<fb_quadlet_t*>( raw ) ) )
586     {
587         return false;
588     }
589
590     Util::Cmd::BufferDeserialize de( raw, buf_length );
591     if ( !writeRequestCmd.deserialize( de ) ) {
592         debugError( "readResponse: deserialize failed\n" );
593         return false;
594     }
595
596     bool result =
597         writeRequestCmd.getProtocolVersion()
598         == writeRequestCmd.getRespProtocolVersion();
599     result &=
600         writeRequestCmd.getCommandId()
601         == writeRequestCmd.getRespCommandId();
602     result &=
603         writeRequestCmd.getCommandCode()
604         == writeRequestCmd.getRespCommandCode();
605     #ifdef DEBUG
606        if ( !result ) {
607            debugError( "readResponse: protocol version: %d expected, "
608                        " %d reported\n",
609                        writeRequestCmd.getProtocolVersion(),
610                        writeRequestCmd.getRespProtocolVersion() );
611            debugError( "readResponse: command id: %d expected, "
612                        " %d reported\n",
613                        writeRequestCmd.getCommandId(),
614                        writeRequestCmd.getRespCommandId() );
615            debugError( "readResponse: command code: %d expected, "
616                        " %d reported\n",
617                        writeRequestCmd.getCommandCode(),
618                        writeRequestCmd.getRespCommandCode() );
619        }
620     #endif
621     return result;
622 }
623
624 bool
625 BeBoB::BootloaderManager::startBootloaderCmd()
626 {
627     CommandCodesReset cmd( m_protocolVersion,
628                            CommandCodesReset::eSM_Bootloader ) ;
629     if ( !writeRequest( cmd ) ) {
630         debugError( "startBootloaderCmd: writeRequest failed\n" );
631         return false;
632     }
633
634     waitForBusReset();
635     if ( !cacheInfoRegisters( MaxRetries ) ) {
636         debugError( "startBootloaderCmd: Could not read info registers\n" );
637         return false;
638     }
639
640     // wait for bootloader finish startup sequence
641     // there is no way to find out when it has finished
642     sleep( 10 );
643
644     return true;
645 }
646
647 bool
648 BeBoB::BootloaderManager::startApplicationCmd()
649 {
650     CommandCodesGo cmd( m_protocolVersion,
651                            CommandCodesGo::eSM_Application ) ;
652     if ( !writeRequest( cmd ) ) {
653         debugError( "startApplicationCmd: writeRequest failed\n" );
654         return false;
655     }
656
657     return true;
658 }
659
660 bool
661 BeBoB::BootloaderManager::programGUIDCmd( fb_octlet_t guid )
662 {
663     CommandCodesProgramGUID cmd( m_protocolVersion, guid );
664     if ( !writeRequest( cmd ) ) {
665         debugError( "programGUIDCmd: writeRequest failed\n" );
666         return false;
667     }
668
669     sleep( 1 );
670
671     return true;
672 }
673
674 bool
675 BeBoB::BootloaderManager::initializePersParamCmd()
676 {
677     CommandCodesInitializePersParam cmd( m_protocolVersion );
678     if ( !writeRequest( cmd ) ) {
679         debugError( "initializePersParamCmd: writeRequest failed\n" );
680         return false;
681     }
682
683     sleep( 1 );
684
685     return true;
686 }
687
688 bool
689 BeBoB::BootloaderManager::initializeConfigToFactorySettingCmd()
690 {
691     CommandCodesInitializeConfigToFactorySetting cmd( m_protocolVersion );
692     if ( !writeRequest( cmd ) ) {
693         debugError( "initializeConfigToFactorySettingCmd: writeRequest failed\n" );
694         return false;
695     }
696
697     sleep( 5 );
698
699     return true;
700 }
701
702 bool
703 BeBoB::BootloaderManager::checkDeviceCompatibility( BCD& bcd )
704 {
705     fb_quadlet_t vendorOUI = (  m_cachedInfoRegs.m_guid >> 40 );
706
707
708     if ( ( vendorOUI == bcd.getVendorOUI() )
709          && ( m_cachedInfoRegs.m_softwareId == bcd.getSoftwareId() ) )
710     {
711         return true;
712     }
713
714     printf( "vendorOUI = 0x%08x\n", vendorOUI );
715     printf( "BCD vendorOUI = 0x%08x\n", bcd.getVendorOUI() );
716     printf( "software ID = 0x%08x\n", m_cachedInfoRegs.m_softwareId );
717     printf( "BCD software ID = 0x%08x\n", bcd.getSoftwareId() );
718
719     return false;
720 }
Note: See TracBrowser for help on using the browser.