root/branches/libffado-2.0/src/bebob/bebob_avplug.cpp

Revision 1241, 22.8 kB (checked in by ppalmers, 13 years ago)

update BeBoB constructors (thx slack) (closes #129, #127)

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/bebob_avplug.h"
25 #include "bebob/bebob_avdevice.h"
26 #include "libieee1394/configrom.h"
27
28 #include "libieee1394/ieee1394service.h"
29 #include "libutil/cmd_serialize.h"
30
31 #include <sstream>
32
33 using namespace AVC;
34
35 namespace BeBoB {
36
37 Plug::Plug( AVC::Unit* unit,
38             AVC::Subunit* subunit,
39             AVC::function_block_type_t functionBlockType,
40             AVC::function_block_type_t functionBlockId,
41             AVC::Plug::EPlugAddressType plugAddressType,
42             AVC::Plug::EPlugDirection plugDirection,
43             AVC::plug_id_t plugId )
44     : AVC::Plug( unit,
45                  subunit,
46                  functionBlockType,
47                  functionBlockId,
48                  plugAddressType,
49                  plugDirection,
50                  plugId )
51 {
52     debugOutput( DEBUG_LEVEL_VERBOSE,
53                  "nodeId = %d, subunitType = %d, "
54                  "subunitId = %d, functionBlockType = %d, "
55                  "functionBlockId = %d, addressType = %d, "
56                  "direction = %d, id = %d\n",
57                  unit->getConfigRom().getNodeId(),
58                  getSubunitType(),
59                  getSubunitId(),
60                  functionBlockType,
61                  functionBlockId,
62                  plugAddressType,
63                  plugDirection,
64                  plugId );
65 }
66
67 Plug::Plug( AVC::Unit* unit,
68             AVC::Subunit* subunit,
69             AVC::function_block_type_t functionBlockType,
70             AVC::function_block_type_t functionBlockId,
71             AVC::Plug::EPlugAddressType plugAddressType,
72             AVC::Plug::EPlugDirection plugDirection,
73             AVC::plug_id_t plugId,
74             int globalId )
75     : AVC::Plug( unit,
76                  subunit,
77                  functionBlockType,
78                  functionBlockId,
79                  plugAddressType,
80                  plugDirection,
81                  plugId,
82                  globalId )
83 {
84     debugOutput( DEBUG_LEVEL_VERBOSE,
85                  "nodeId = %d, subunitType = %d, "
86                  "subunitId = %d, functionBlockType = %d, "
87                  "functionBlockId = %d, addressType = %d, "
88                  "direction = %d, id = %d\n",
89                  unit->getConfigRom().getNodeId(),
90                  getSubunitType(),
91                  getSubunitId(),
92                  functionBlockType,
93                  functionBlockId,
94                  plugAddressType,
95                  plugDirection,
96                  plugId );
97 }
98
99 Plug::Plug( const Plug& rhs )
100     : AVC::Plug( rhs )
101 {
102
103 }
104
105 Plug::Plug()
106     : AVC::Plug()
107 {
108 }
109
110 Plug::~Plug()
111 {
112
113 }
114
115 bool
116 Plug::discover()
117 {
118     if ( !discoverPlugType() ) {
119         debugError( "discover: Could not discover plug type (%d,%d,%d,%d,%d)\n",
120                     m_unit->getConfigRom().getNodeId(), getSubunitType(), getSubunitId(), m_direction, m_id );
121         return false;
122     }
123
124     if ( !discoverName() ) {
125         debugError( "Could not discover name (%d,%d,%d,%d,%d)\n",
126                     m_unit->getConfigRom().getNodeId(), getSubunitType(), getSubunitId(), m_direction, m_id );
127         return false;
128     }
129
130     if ( !discoverNoOfChannels() ) {
131         debugError( "Could not discover number of channels "
132                     "(%d,%d,%d,%d,%d)\n",
133                     m_unit->getConfigRom().getNodeId(), getSubunitType(), getSubunitId(), m_direction, m_id );
134         return false;
135     }
136
137     if ( !discoverChannelPosition() ) {
138         debugError( "Could not discover channel positions "
139                     "(%d,%d,%d,%d,%d)\n",
140                     m_unit->getConfigRom().getNodeId(), getSubunitType(), getSubunitId(), m_direction, m_id );
141         return false;
142     }
143
144     if ( !discoverChannelName() ) {
145         debugError( "Could not discover channel name "
146                     "(%d,%d,%d,%d,%d)\n",
147                     m_unit->getConfigRom().getNodeId(), getSubunitType(), getSubunitId(), m_direction, m_id );
148         return false;
149     }
150
151     if ( !discoverClusterInfo() ) {
152         debugError( "Could not discover channel name "
153                     "(%d,%d,%d,%d,%d)\n",
154                     m_unit->getConfigRom().getNodeId(), getSubunitType(), getSubunitId(), m_direction, m_id );
155         return false;
156     }
157
158     if ( !discoverStreamFormat() ) {
159         debugError( "Could not discover stream format "
160                     "(%d,%d,%d,%d,%d)\n",
161                     m_unit->getConfigRom().getNodeId(), getSubunitType(), getSubunitId(), m_direction, m_id );
162         return false;
163     }
164
165     if ( !discoverSupportedStreamFormats() ) {
166         debugError( "Could not discover supported stream formats "
167                     "(%d,%d,%d,%d,%d)\n",
168                     m_unit->getConfigRom().getNodeId(), getSubunitType(), getSubunitId(), m_direction, m_id );
169         return false;
170     }
171
172     return m_unit->getPlugManager().addPlug( *this );
173 }
174
175 bool
176 Plug::discoverConnections()
177 {
178     return discoverConnectionsInput() && discoverConnectionsOutput();
179 }
180
181 bool
182 Plug::discoverPlugType()
183 {
184     ExtendedPlugInfoCmd extPlugInfoCmd = setPlugAddrToPlugInfoCmd();
185     ExtendedPlugInfoInfoType extendedPlugInfoInfoType(
186         ExtendedPlugInfoInfoType::eIT_PlugType );
187     extendedPlugInfoInfoType.initialize();
188     extPlugInfoCmd.setInfoType( extendedPlugInfoInfoType );
189     extPlugInfoCmd.setVerbose( getDebugLevel() );
190
191     if ( !extPlugInfoCmd.fire() ) {
192         debugError( "plug type command failed\n" );
193         return false;
194     }
195
196     m_infoPlugType = eAPT_Unknown;
197
198     if ( extPlugInfoCmd.getResponse() == AVCCommand::eR_Implemented ) {
199
200         ExtendedPlugInfoInfoType* infoType = extPlugInfoCmd.getInfoType();
201         if ( infoType
202              && infoType->m_plugType )
203         {
204             plug_type_t plugType = infoType->m_plugType->m_plugType;
205
206             debugOutput( DEBUG_LEVEL_VERBOSE,
207                          "plug %d is of type %d (%s)\n",
208                          m_id,
209                          plugType,
210                          extendedPlugInfoPlugTypeToString( plugType ) );
211             switch ( plugType ) {
212             case ExtendedPlugInfoPlugTypeSpecificData::eEPIPT_IsoStream:
213                 m_infoPlugType = eAPT_IsoStream;
214                 break;
215             case ExtendedPlugInfoPlugTypeSpecificData::eEPIPT_AsyncStream:
216                 m_infoPlugType = eAPT_AsyncStream;
217                 break;
218             case ExtendedPlugInfoPlugTypeSpecificData::eEPIPT_Midi:
219                 m_infoPlugType = eAPT_Midi;
220                 break;
221             case ExtendedPlugInfoPlugTypeSpecificData::eEPIPT_Sync:
222                 m_infoPlugType = eAPT_Sync;
223                 break;
224             case ExtendedPlugInfoPlugTypeSpecificData::eEPIPT_Analog:
225                 m_infoPlugType = eAPT_Analog;
226                 break;
227             case ExtendedPlugInfoPlugTypeSpecificData::eEPIPT_Digital:
228                 m_infoPlugType = eAPT_Digital;
229                 break;
230             default:
231                 m_infoPlugType = eAPT_Unknown;
232
233             }
234         }
235     } else {
236         debugError( "Plug does not implement extended plug info plug "
237                     "type info command\n" );
238         return false;
239     }
240
241    return true;
242 }
243
244 bool
245 Plug::discoverName()
246 {
247     ExtendedPlugInfoCmd extPlugInfoCmd = setPlugAddrToPlugInfoCmd();
248     ExtendedPlugInfoInfoType extendedPlugInfoInfoType(
249         ExtendedPlugInfoInfoType::eIT_PlugName );
250     extendedPlugInfoInfoType.initialize();
251     extPlugInfoCmd.setInfoType( extendedPlugInfoInfoType );
252     extPlugInfoCmd.setVerbose( getDebugLevel() );
253
254     if ( !extPlugInfoCmd.fire() ) {
255         debugError( "name command failed\n" );
256         return false;
257     }
258
259     ExtendedPlugInfoInfoType* infoType = extPlugInfoCmd.getInfoType();
260     if ( infoType
261          && infoType->m_plugName )
262     {
263         std::string name =
264             infoType->m_plugName->m_name;
265
266         debugOutput( DEBUG_LEVEL_VERBOSE,
267                      "plug %d has name '%s'\n",
268                      m_id,
269                      name.c_str() );
270
271         m_name = name;
272     }
273     return true;
274 }
275
276 bool
277 Plug::discoverNoOfChannels()
278 {
279     ExtendedPlugInfoCmd extPlugInfoCmd = setPlugAddrToPlugInfoCmd();
280     //extPlugInfoCmd.setVerbose( true );
281     ExtendedPlugInfoInfoType extendedPlugInfoInfoType(
282         ExtendedPlugInfoInfoType::eIT_NoOfChannels );
283     extendedPlugInfoInfoType.initialize();
284     extPlugInfoCmd.setInfoType( extendedPlugInfoInfoType );
285     extPlugInfoCmd.setVerbose( getDebugLevel() );
286
287     if ( !extPlugInfoCmd.fire() ) {
288         debugError( "number of channels command failed\n" );
289         return false;
290     }
291
292     ExtendedPlugInfoInfoType* infoType = extPlugInfoCmd.getInfoType();
293     if ( infoType
294          && infoType->m_plugNrOfChns )
295     {
296         nr_of_channels_t nrOfChannels
297             = infoType->m_plugNrOfChns->m_nrOfChannels;
298
299         debugOutput( DEBUG_LEVEL_VERBOSE,
300                      "plug %d has %d channels\n",
301                      m_id,
302                      nrOfChannels );
303
304         m_nrOfChannels = nrOfChannels;
305     }
306     return true;
307 }
308
309 bool
310 Plug::discoverChannelPosition()
311 {
312     ExtendedPlugInfoCmd extPlugInfoCmd = setPlugAddrToPlugInfoCmd();
313     ExtendedPlugInfoInfoType extendedPlugInfoInfoType(
314         ExtendedPlugInfoInfoType::eIT_ChannelPosition );
315     extendedPlugInfoInfoType.initialize();
316     extPlugInfoCmd.setInfoType( extendedPlugInfoInfoType );
317     extPlugInfoCmd.setVerbose( getDebugLevel() );
318
319     if ( !extPlugInfoCmd.fire() ) {
320         debugError( "channel position command failed\n" );
321         return false;
322     }
323
324     ExtendedPlugInfoInfoType* infoType = extPlugInfoCmd.getInfoType();
325     if ( infoType
326          && infoType->m_plugChannelPosition )
327     {
328         if ( !copyClusterInfo( *( infoType->m_plugChannelPosition ) ) ) {
329             debugError( "Could not copy channel position "
330                         "information\n" );
331             return false;
332         }
333
334         debugOutput( DEBUG_LEVEL_VERBOSE,
335                      "plug %d: channel position information "
336                      "retrieved\n",
337                      m_id );
338
339         debugOutputClusterInfos( DEBUG_LEVEL_VERBOSE );
340     }
341
342     return true;
343 }
344
345 bool
346 Plug::copyClusterInfo(ExtendedPlugInfoPlugChannelPositionSpecificData&
347                         channelPositionData )
348 {
349     int index = 1;
350     for ( ExtendedPlugInfoPlugChannelPositionSpecificData::ClusterInfoVector::const_iterator it
351               = channelPositionData.m_clusterInfos.begin();
352           it != channelPositionData.m_clusterInfos.end();
353           ++it )
354     {
355         const ExtendedPlugInfoPlugChannelPositionSpecificData::ClusterInfo*
356             extPlugSpClusterInfo = &( *it );
357
358         ClusterInfo clusterInfo;
359         clusterInfo.m_nrOfChannels = extPlugSpClusterInfo->m_nrOfChannels;
360         clusterInfo.m_index = index;
361         index++;
362
363         for (  ExtendedPlugInfoPlugChannelPositionSpecificData::ChannelInfoVector::const_iterator cit
364                   = extPlugSpClusterInfo->m_channelInfos.begin();
365               cit != extPlugSpClusterInfo->m_channelInfos.end();
366               ++cit )
367         {
368             const ExtendedPlugInfoPlugChannelPositionSpecificData::ChannelInfo*
369                 extPlugSpChannelInfo = &( *cit );
370
371             ChannelInfo channelInfo;
372             channelInfo.m_streamPosition =
373                 extPlugSpChannelInfo->m_streamPosition-1;
374             // FIXME: this can only become a mess with the two meanings
375             //        of the location parameter. the audio style meaning
376             //        starts from 1, the midi style meaning from 0
377             //        lucky for us we recalculate this for the midi channels
378             //        and don't use this value.
379             channelInfo.m_location =
380                 extPlugSpChannelInfo->m_location;
381
382             clusterInfo.m_channelInfos.push_back( channelInfo );
383         }
384         m_clusterInfos.push_back( clusterInfo );
385     }
386
387     return true;
388 }
389
390 bool
391 Plug::discoverChannelName()
392 {
393     for ( ClusterInfoVector::iterator clit = m_clusterInfos.begin();
394           clit != m_clusterInfos.end();
395           ++clit )
396     {
397         ClusterInfo* clitInfo = &*clit;
398
399         for ( ChannelInfoVector::iterator pit =  clitInfo->m_channelInfos.begin();
400               pit != clitInfo->m_channelInfos.end();
401               ++pit )
402         {
403             ChannelInfo* channelInfo = &*pit;
404
405             ExtendedPlugInfoCmd extPlugInfoCmd = setPlugAddrToPlugInfoCmd();
406             ExtendedPlugInfoInfoType extendedPlugInfoInfoType(
407                 ExtendedPlugInfoInfoType::eIT_ChannelName );
408             extendedPlugInfoInfoType.initialize();
409             extPlugInfoCmd.setInfoType( extendedPlugInfoInfoType );
410             extPlugInfoCmd.setVerbose( getDebugLevel() );
411
412             ExtendedPlugInfoInfoType* infoType =
413                 extPlugInfoCmd.getInfoType();
414             if ( infoType ) {
415                 infoType->m_plugChannelName->m_streamPosition =
416                     channelInfo->m_streamPosition + 1;
417             }
418             if ( !extPlugInfoCmd.fire() ) {
419                 debugError( "channel name command failed\n" );
420                 return false;
421             }
422             infoType = extPlugInfoCmd.getInfoType();
423             if ( infoType
424                  && infoType->m_plugChannelName )
425             {
426                 debugOutput( DEBUG_LEVEL_VERBOSE,
427                              "plug %d stream "
428                              "position %d: channel name = %s\n",
429                              m_id,
430                              channelInfo->m_streamPosition,
431                              infoType->m_plugChannelName->m_plugChannelName.c_str() );
432                 channelInfo->m_name =
433                     infoType->m_plugChannelName->m_plugChannelName;
434             }
435
436         }
437     }
438
439     return true;
440 }
441
442 bool
443 Plug::discoverClusterInfo()
444 {
445     if ( m_infoPlugType == eAPT_Sync )
446     {
447         // If the plug is of type sync it is either a normal 2 channel
448         // stream (not compound stream) or it is a compound stream
449         // with exactly one cluster. This depends on the
450         // extended stream format command version which is used.
451         // We are not interested in this plug so we skip it.
452         debugOutput( DEBUG_LEVEL_VERBOSE,
453                      "%s plug %d is of type sync -> skip\n",
454                      getName(),
455                      m_id );
456         return true;
457     }
458
459     for ( ClusterInfoVector::iterator clit = m_clusterInfos.begin();
460           clit != m_clusterInfos.end();
461           ++clit )
462     {
463         ClusterInfo* clusterInfo = &*clit;
464
465         ExtendedPlugInfoCmd extPlugInfoCmd = setPlugAddrToPlugInfoCmd();
466         ExtendedPlugInfoInfoType extendedPlugInfoInfoType(
467             ExtendedPlugInfoInfoType::eIT_ClusterInfo );
468         extendedPlugInfoInfoType.initialize();
469         extPlugInfoCmd.setInfoType( extendedPlugInfoInfoType );
470         extPlugInfoCmd.setVerbose( getDebugLevel() );
471
472         extPlugInfoCmd.getInfoType()->m_plugClusterInfo->m_clusterIndex =
473             clusterInfo->m_index;
474
475         if ( !extPlugInfoCmd.fire() ) {
476             debugError( "cluster info command failed\n" );
477             return false;
478         }
479
480         ExtendedPlugInfoInfoType* infoType = extPlugInfoCmd.getInfoType();
481         if ( infoType
482              && infoType->m_plugClusterInfo )
483         {
484             debugOutput( DEBUG_LEVEL_VERBOSE,
485                          "%s plug %d: cluster index = %d, "
486                          "portType %s, cluster name = %s\n",
487                          getName(),
488                          m_id,
489                          infoType->m_plugClusterInfo->m_clusterIndex,
490                          extendedPlugInfoClusterInfoPortTypeToString(
491                              infoType->m_plugClusterInfo->m_portType ),
492                          infoType->m_plugClusterInfo->m_clusterName.c_str() );
493
494             clusterInfo->m_portType = infoType->m_plugClusterInfo->m_portType;
495             clusterInfo->m_name = infoType->m_plugClusterInfo->m_clusterName;
496         }
497     }
498
499     return true;
500 }
501
502 bool
503 Plug::discoverConnectionsInput()
504 {
505     ExtendedPlugInfoCmd extPlugInfoCmd = setPlugAddrToPlugInfoCmd();
506     ExtendedPlugInfoInfoType extendedPlugInfoInfoType(
507         ExtendedPlugInfoInfoType::eIT_PlugInput );
508     extendedPlugInfoInfoType.initialize();
509     extPlugInfoCmd.setInfoType( extendedPlugInfoInfoType );
510     extPlugInfoCmd.setVerbose( getDebugLevel() );
511
512     if ( !extPlugInfoCmd.fire() ) {
513         debugError( "plug type command failed\n" );
514         return false;
515     }
516
517     if ( extPlugInfoCmd.getResponse() == AVCCommand::eR_Rejected ) {
518         // Plugs does not like to be asked about connections
519         debugOutput( DEBUG_LEVEL_VERBOSE, "Plug '%s' rejects "
520                      "connections command\n",
521                      getName() );
522         return true;
523     }
524
525     ExtendedPlugInfoInfoType* infoType = extPlugInfoCmd.getInfoType();
526     if ( infoType
527          && infoType->m_plugInput )
528     {
529         PlugAddressSpecificData* plugAddress
530             = infoType->m_plugInput->m_plugAddress;
531
532         if ( plugAddress->m_addressMode ==
533              PlugAddressSpecificData::ePAM_Undefined )
534         {
535             // This plug has no input connection
536             return true;
537         }
538
539         if ( !discoverConnectionsFromSpecificData( eAPD_Input,
540                                                    plugAddress,
541                                                    m_inputConnections ) )
542         {
543             debugWarning( "Could not discover connnections for plug '%s'\n",
544                           getName() );
545         }
546     } else {
547         debugError( "no valid info type for plug '%s'\n", getName() );
548         return false;
549     }
550
551     return true;
552 }
553
554 bool
555 Plug::discoverConnectionsOutput()
556 {
557     ExtendedPlugInfoCmd extPlugInfoCmd = setPlugAddrToPlugInfoCmd();
558     ExtendedPlugInfoInfoType extendedPlugInfoInfoType(
559         ExtendedPlugInfoInfoType::eIT_PlugOutput );
560     extendedPlugInfoInfoType.initialize();
561     extPlugInfoCmd.setInfoType( extendedPlugInfoInfoType );
562     extPlugInfoCmd.setVerbose( getDebugLevel() );
563
564     if ( !extPlugInfoCmd.fire() ) {
565         debugError( "plug type command failed\n" );
566         return false;
567     }
568
569     if ( extPlugInfoCmd.getResponse() == AVCCommand::eR_Rejected ) {
570         // Plugs does not like to be asked about connections
571         debugOutput( DEBUG_LEVEL_VERBOSE, "Plug '%s' rejects "
572                      "connections command\n",
573                      getName() );
574         return true;
575     }
576
577     ExtendedPlugInfoInfoType* infoType = extPlugInfoCmd.getInfoType();
578     if ( infoType
579          && infoType->m_plugOutput )
580     {
581         if ( infoType->m_plugOutput->m_nrOfOutputPlugs
582              != infoType->m_plugOutput->m_outputPlugAddresses.size() )
583         {
584             debugError( "number of output plugs (%d) disagree with "
585                         "number of elements in plug address vector (%d)\n",
586                         infoType->m_plugOutput->m_nrOfOutputPlugs,
587                         infoType->m_plugOutput->m_outputPlugAddresses.size());
588         }
589
590         if ( infoType->m_plugOutput->m_nrOfOutputPlugs == 0 ) {
591             // This plug has no output connections
592             return true;
593         }
594
595         for ( unsigned int i = 0;
596               i < infoType->m_plugOutput->m_outputPlugAddresses.size();
597               ++i )
598         {
599             PlugAddressSpecificData* plugAddress
600                 = infoType->m_plugOutput->m_outputPlugAddresses[i];
601
602             if ( !discoverConnectionsFromSpecificData( eAPD_Output,
603                                                        plugAddress,
604                                                        m_outputConnections ) )
605             {
606                 debugWarning( "Could not discover connnections for "
607                               "plug '%s'\n", getName() );
608             }
609         }
610     } else {
611         debugError( "no valid info type for plug '%s'\n", getName() );
612         return false;
613     }
614
615     return true;
616 }
617
618 ExtendedPlugInfoCmd
619 Plug::setPlugAddrToPlugInfoCmd()
620 {
621     ExtendedPlugInfoCmd extPlugInfoCmd( m_unit->get1394Service() );
622
623     switch( getSubunitType() ) {
624     case eST_Unit:
625         {
626             UnitPlugAddress::EPlugType ePlugType =
627                 UnitPlugAddress::ePT_Unknown;
628             switch ( m_addressType ) {
629                 case eAPA_PCR:
630                     ePlugType = UnitPlugAddress::ePT_PCR;
631                     break;
632                 case eAPA_ExternalPlug:
633                     ePlugType = UnitPlugAddress::ePT_ExternalPlug;
634                     break;
635                 case eAPA_AsynchronousPlug:
636                     ePlugType = UnitPlugAddress::ePT_AsynchronousPlug;
637                     break;
638                 default:
639                     ePlugType = UnitPlugAddress::ePT_Unknown;
640             }
641             UnitPlugAddress unitPlugAddress( ePlugType,
642                                              m_id );
643             extPlugInfoCmd.setPlugAddress(
644                 PlugAddress( convertPlugDirection( getPlugDirection() ),
645                              PlugAddress::ePAM_Unit,
646                              unitPlugAddress ) );
647         }
648         break;
649     case eST_Music:
650     case eST_Audio:
651         {
652             switch( m_addressType ) {
653             case eAPA_SubunitPlug:
654             {
655                 SubunitPlugAddress subunitPlugAddress( m_id );
656                 extPlugInfoCmd.setPlugAddress(
657                     PlugAddress(
658                         convertPlugDirection( getPlugDirection() ),
659                         PlugAddress::ePAM_Subunit,
660                         subunitPlugAddress ) );
661             }
662             break;
663             case eAPA_FunctionBlockPlug:
664             {
665                 FunctionBlockPlugAddress functionBlockPlugAddress(
666                     m_functionBlockType,
667                     m_functionBlockId,
668                     m_id );
669                 extPlugInfoCmd.setPlugAddress(
670                     PlugAddress(
671                         convertPlugDirection( getPlugDirection() ),
672                         PlugAddress::ePAM_FunctionBlock,
673                         functionBlockPlugAddress ) );
674             }
675             break;
676             default:
677                 extPlugInfoCmd.setPlugAddress(PlugAddress());
678             }
679         }
680         break;
681     default:
682         debugError( "Unknown subunit type\n" );
683     }
684
685     extPlugInfoCmd.setNodeId( m_unit->getConfigRom().getNodeId() );
686     extPlugInfoCmd.setCommandType( AVCCommand::eCT_Status );
687     extPlugInfoCmd.setSubunitId( getSubunitId() );
688     extPlugInfoCmd.setSubunitType( getSubunitType() );
689
690     return extPlugInfoCmd;
691 }
692
693 }
Note: See TracBrowser for help on using the browser.