root/branches/ppalmers-streaming/src/dice/dice_avdevice.cpp

Revision 722, 49.4 kB (checked in by ppalmers, 13 years ago)

more rewrite of streaming

Line 
1 /*
2  * Copyright (C) 2005-2007 by Pieter Palmers
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 library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License version 2.1, as published by the Free Software Foundation;
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
21  * MA 02110-1301 USA
22  */
23
24 #include "dice/dice_avdevice.h"
25 #include "dice/dice_defines.h"
26
27 #include "libieee1394/configrom.h"
28 #include "libieee1394/ieee1394service.h"
29
30 #include "debugmodule/debugmodule.h"
31
32 #include <string>
33 #include <stdint.h>
34 #include <assert.h>
35 #include <netinet/in.h>
36 #include <libraw1394/csr.h>
37
38 #include <iostream>
39 #include <sstream>
40
41 #include <string>
42 using namespace std;
43
44 namespace Dice {
45
46 // to define the supported devices
47 static VendorModelEntry supportedDeviceList[] =
48 {
49     // vendor id, model id, vendor name, model name
50     {FW_VENDORID_TCAT, 0x00000002, "TCAT", "DiceII EVM"},
51     {FW_VENDORID_TCAT, 0x00000004, "TCAT", "DiceII EVM (vxx)"},
52 };
53
54 DiceAvDevice::DiceAvDevice( Ieee1394Service& ieee1394Service,
55                             std::auto_ptr<ConfigRom>( configRom ))
56     : FFADODevice( ieee1394Service, configRom )
57     , m_model( NULL )
58     , m_global_reg_offset (0xFFFFFFFFLU)
59     , m_global_reg_size (0xFFFFFFFFLU)
60     , m_tx_reg_offset (0xFFFFFFFFLU)
61     , m_tx_reg_size (0xFFFFFFFFLU)
62     , m_rx_reg_offset (0xFFFFFFFFLU)
63     , m_rx_reg_size (0xFFFFFFFFLU)
64     , m_unused1_reg_offset (0xFFFFFFFFLU)
65     , m_unused1_reg_size (0xFFFFFFFFLU)
66     , m_unused2_reg_offset (0xFFFFFFFFLU)
67     , m_unused2_reg_size (0xFFFFFFFFLU)
68     , m_nb_tx (0xFFFFFFFFLU)
69     , m_tx_size (0xFFFFFFFFLU)
70     , m_nb_rx (0xFFFFFFFFLU)
71     , m_rx_size (0xFFFFFFFFLU)
72     , m_notifier (NULL)
73 {
74     debugOutput( DEBUG_LEVEL_VERBOSE, "Created Dice::DiceAvDevice (NodeID %d)\n",
75                  getConfigRom().getNodeId() );
76
77 }
78
79 DiceAvDevice::~DiceAvDevice()
80 {
81     // FIXME: clean up m_receiveProcessors & xmit
82
83     if (m_notifier) {
84         unlock();
85     }
86 }
87
88 bool
89 DiceAvDevice::probe( ConfigRom& configRom )
90 {
91     unsigned int vendorId = configRom.getNodeVendorId();
92     unsigned int modelId = configRom.getModelId();
93
94     for ( unsigned int i = 0;
95           i < ( sizeof( supportedDeviceList )/sizeof( VendorModelEntry ) );
96           ++i )
97     {
98         if ( ( supportedDeviceList[i].vendor_id == vendorId )
99              && ( supportedDeviceList[i].model_id == modelId )
100            )
101         {
102             return true;
103         }
104     }
105
106     return false;
107 }
108
109 FFADODevice *
110 DiceAvDevice::createDevice( Ieee1394Service& ieee1394Service,
111                             std::auto_ptr<ConfigRom>( configRom ))
112 {
113     return new DiceAvDevice(ieee1394Service, configRom );
114 }
115
116 bool
117 DiceAvDevice::discover()
118 {
119     unsigned int vendorId = m_pConfigRom->getNodeVendorId();
120     unsigned int modelId = m_pConfigRom->getModelId();
121
122     for ( unsigned int i = 0;
123           i < ( sizeof( supportedDeviceList )/sizeof( VendorModelEntry ) );
124           ++i )
125     {
126         if ( ( supportedDeviceList[i].vendor_id == vendorId )
127              && ( supportedDeviceList[i].model_id == modelId )
128            )
129         {
130             m_model = &(supportedDeviceList[i]);
131         }
132     }
133
134     if (m_model == NULL) {
135         debugWarning("DiceAvDevice::discover() called for a non-dice device");
136         return false;
137     }
138
139     if ( !initIoFunctions() ) {
140         debugError("Could not initialize I/O functions\n");
141         return false;
142     }
143
144     debugOutput( DEBUG_LEVEL_VERBOSE, "found %s %s (nick: %s)\n",
145                 m_model->vendor_name, m_model->model_name, getDeviceNickName().c_str());
146
147     return true;
148 }
149
150 int
151 DiceAvDevice::getSamplingFrequency( ) {
152     int samplingFrequency;
153
154     fb_quadlet_t clockreg;
155     if (!readGlobalReg(DICE_REGISTER_GLOBAL_CLOCK_SELECT, &clockreg)) {
156         debugError("Could not read CLOCK_SELECT register\n");
157         return false;
158     }
159
160     clockreg = DICE_GET_RATE(clockreg);
161
162     switch (clockreg) {
163         case DICE_RATE_32K:      samplingFrequency = 32000;  break;
164         case DICE_RATE_44K1:     samplingFrequency = 44100;  break;
165         case DICE_RATE_48K:      samplingFrequency = 48000;  break;
166         case DICE_RATE_88K2:     samplingFrequency = 88200;  break;
167         case DICE_RATE_96K:      samplingFrequency = 96000;  break;
168         case DICE_RATE_176K4:    samplingFrequency = 176400; break;
169         case DICE_RATE_192K:     samplingFrequency = 192000; break;
170         case DICE_RATE_ANY_LOW:  samplingFrequency = 0;   break;
171         case DICE_RATE_ANY_MID:  samplingFrequency = 0;   break;
172         case DICE_RATE_ANY_HIGH: samplingFrequency = 0;  break;
173         case DICE_RATE_NONE:     samplingFrequency = 0;     break;
174         default:                 samplingFrequency = 0; break;
175     }
176
177     return samplingFrequency;
178 }
179
180 int
181 DiceAvDevice::getConfigurationId()
182 {
183     return 0;
184 }
185
186 bool
187 DiceAvDevice::setSamplingFrequency( int samplingFrequency )
188 {
189     debugOutput(DEBUG_LEVEL_VERBOSE, "Setting sample rate: %d\n",
190         (samplingFrequency));
191
192     bool supported=false;
193     fb_quadlet_t select=0x0;
194
195     switch ( samplingFrequency ) {
196     default:
197     case 22050:
198     case 24000:
199         supported=false;
200         break;
201     case 32000:
202         supported=maskedCheckNotZeroGlobalReg(
203                     DICE_REGISTER_GLOBAL_CLOCKCAPABILITIES,
204                     DICE_CLOCKCAP_RATE_32K);
205         select=DICE_RATE_32K;
206         break;
207     case 44100:
208         supported=maskedCheckNotZeroGlobalReg(
209                     DICE_REGISTER_GLOBAL_CLOCKCAPABILITIES,
210                     DICE_CLOCKCAP_RATE_44K1);
211         select=DICE_RATE_44K1;
212         break;
213     case 48000:
214         supported=maskedCheckNotZeroGlobalReg(
215                     DICE_REGISTER_GLOBAL_CLOCKCAPABILITIES,
216                     DICE_CLOCKCAP_RATE_48K);
217         select=DICE_RATE_48K;
218         break;
219     case 88200:
220         supported=maskedCheckNotZeroGlobalReg(
221                     DICE_REGISTER_GLOBAL_CLOCKCAPABILITIES,
222                     DICE_CLOCKCAP_RATE_88K2);
223         select=DICE_RATE_88K2;
224         break;
225     case 96000:
226         supported=maskedCheckNotZeroGlobalReg(
227                     DICE_REGISTER_GLOBAL_CLOCKCAPABILITIES,
228                     DICE_CLOCKCAP_RATE_96K);
229         select=DICE_RATE_96K;
230         break;
231     case 176400:
232         supported=maskedCheckNotZeroGlobalReg(
233                     DICE_REGISTER_GLOBAL_CLOCKCAPABILITIES,
234                     DICE_CLOCKCAP_RATE_176K4);
235         select=DICE_RATE_176K4;
236         break;
237     case 192000:
238         supported=maskedCheckNotZeroGlobalReg(
239                     DICE_REGISTER_GLOBAL_CLOCKCAPABILITIES,
240                     DICE_CLOCKCAP_RATE_192K);
241         select=DICE_RATE_192K;
242         break;
243     }
244
245     if (!supported) {
246         debugWarning("Unsupported sample rate: %d\n", (samplingFrequency));
247         return false;
248     }
249
250     if (isIsoStreamingEnabled()) {
251         debugError("Cannot change samplerate while streaming is enabled\n");
252         return false;
253     }
254
255     fb_quadlet_t clockreg;
256     if (!readGlobalReg(DICE_REGISTER_GLOBAL_CLOCK_SELECT, &clockreg)) {
257         debugError("Could not read CLOCK_SELECT register\n");
258         return false;
259     }
260
261     clockreg = DICE_SET_RATE(clockreg, select);
262
263     if (!writeGlobalReg(DICE_REGISTER_GLOBAL_CLOCK_SELECT, clockreg)) {
264         debugError("Could not write CLOCK_SELECT register\n");
265         return false;
266     }
267
268     // check if the write succeeded
269     fb_quadlet_t clockreg_verify;
270     if (!readGlobalReg(DICE_REGISTER_GLOBAL_CLOCK_SELECT, &clockreg_verify)) {
271         debugError("Could not read CLOCK_SELECT register\n");
272         return false;
273     }
274
275     if(clockreg != clockreg_verify) {
276         debugError("Samplerate register write failed\n");
277         return false;
278     }
279
280     return true;
281 }
282
283 FFADODevice::ClockSourceVector
284 DiceAvDevice::getSupportedClockSources() {
285     FFADODevice::ClockSourceVector r;
286     return r;
287 }
288
289 bool
290 DiceAvDevice::setActiveClockSource(ClockSource s) {
291     return false;
292 }
293
294 FFADODevice::ClockSource
295 DiceAvDevice::getActiveClockSource() {
296     ClockSource s;
297     return s;
298 }
299
300 void
301 DiceAvDevice::showDevice()
302 {
303     fb_quadlet_t tmp_quadlet;
304     fb_octlet_t tmp_octlet;
305
306     debugOutput(DEBUG_LEVEL_VERBOSE,
307         "%s %s at node %d\n", m_model->vendor_name, m_model->model_name,
308         getNodeId());
309
310     debugOutput(DEBUG_LEVEL_VERBOSE," DICE Parameter Space info:\n");
311     debugOutput(DEBUG_LEVEL_VERBOSE,"  Global  : offset=0x%04X size=%04d\n", m_global_reg_offset, m_global_reg_size);
312     debugOutput(DEBUG_LEVEL_VERBOSE,"  TX      : offset=0x%04X size=%04d\n", m_tx_reg_offset, m_tx_reg_size);
313     debugOutput(DEBUG_LEVEL_VERBOSE,"                nb=%4d size=%04d\n", m_nb_tx, m_tx_size);
314     debugOutput(DEBUG_LEVEL_VERBOSE,"  RX      : offset=0x%04X size=%04d\n", m_rx_reg_offset, m_rx_reg_size);
315     debugOutput(DEBUG_LEVEL_VERBOSE,"                nb=%4d size=%04d\n", m_nb_rx, m_rx_size);
316     debugOutput(DEBUG_LEVEL_VERBOSE,"  UNUSED1 : offset=0x%04X size=%04d\n", m_unused1_reg_offset, m_unused1_reg_size);
317     debugOutput(DEBUG_LEVEL_VERBOSE,"  UNUSED2 : offset=0x%04X size=%04d\n", m_unused2_reg_offset, m_unused2_reg_size);
318
319     debugOutput(DEBUG_LEVEL_VERBOSE," Global param space:\n");
320
321     readGlobalRegBlock(DICE_REGISTER_GLOBAL_OWNER, (fb_quadlet_t *)&tmp_octlet,sizeof(fb_octlet_t));
322     debugOutput(DEBUG_LEVEL_VERBOSE,"  Owner            : 0x%016X\n",tmp_octlet);
323
324     readGlobalReg(DICE_REGISTER_GLOBAL_NOTIFICATION, &tmp_quadlet);
325     debugOutput(DEBUG_LEVEL_VERBOSE,"  Notification     : 0x%08X\n",tmp_quadlet);
326
327     readGlobalReg(DICE_REGISTER_GLOBAL_NOTIFICATION, &tmp_quadlet);
328     debugOutput(DEBUG_LEVEL_VERBOSE,"  Nick name        : %s\n",getDeviceNickName().c_str());
329
330     readGlobalReg(DICE_REGISTER_GLOBAL_CLOCK_SELECT, &tmp_quadlet);
331     debugOutput(DEBUG_LEVEL_VERBOSE,"  Clock Select     : 0x%02X 0x%02X\n",
332         (tmp_quadlet>>8) & 0xFF, tmp_quadlet & 0xFF);
333
334     readGlobalReg(DICE_REGISTER_GLOBAL_ENABLE, &tmp_quadlet);
335     debugOutput(DEBUG_LEVEL_VERBOSE,"  Enable           : %s\n",
336         (tmp_quadlet&0x1?"true":"false"));
337
338     readGlobalReg(DICE_REGISTER_GLOBAL_STATUS, &tmp_quadlet);
339     debugOutput(DEBUG_LEVEL_VERBOSE,"  Clock Status     : %s 0x%02X\n",
340         (tmp_quadlet&0x1?"locked":"not locked"), (tmp_quadlet>>8) & 0xFF);
341
342     readGlobalReg(DICE_REGISTER_GLOBAL_EXTENDED_STATUS, &tmp_quadlet);
343     debugOutput(DEBUG_LEVEL_VERBOSE,"  Extended Status  : 0x%08X\n",tmp_quadlet);
344
345     readGlobalReg(DICE_REGISTER_GLOBAL_SAMPLE_RATE, &tmp_quadlet);
346     debugOutput(DEBUG_LEVEL_VERBOSE,"  Samplerate       : 0x%08X (%lu)\n",tmp_quadlet,tmp_quadlet);
347
348     readGlobalReg(DICE_REGISTER_GLOBAL_VERSION, &tmp_quadlet);
349     debugOutput(DEBUG_LEVEL_VERBOSE,"  Version          : 0x%08X (%u.%u.%u.%u)\n",
350         tmp_quadlet,
351         DICE_DRIVER_SPEC_VERSION_NUMBER_GET_A(tmp_quadlet),
352         DICE_DRIVER_SPEC_VERSION_NUMBER_GET_B(tmp_quadlet),
353         DICE_DRIVER_SPEC_VERSION_NUMBER_GET_C(tmp_quadlet),
354         DICE_DRIVER_SPEC_VERSION_NUMBER_GET_D(tmp_quadlet)
355         );
356
357     readGlobalReg(DICE_REGISTER_GLOBAL_CLOCKCAPABILITIES, &tmp_quadlet);
358     debugOutput(DEBUG_LEVEL_VERBOSE,"  Clock caps       : 0x%08X\n",tmp_quadlet & 0x1FFF007F);
359
360     diceNameVector names=getClockSourceNameString();
361     debugOutput(DEBUG_LEVEL_VERBOSE,"  Clock sources    :\n");
362
363     for ( diceNameVectorIterator it = names.begin();
364           it != names.end();
365           ++it )
366     {
367         debugOutput(DEBUG_LEVEL_VERBOSE,"    %s\n", (*it).c_str());
368     }
369
370     debugOutput(DEBUG_LEVEL_VERBOSE," TX param space:\n");
371     debugOutput(DEBUG_LEVEL_VERBOSE,"  Nb of xmit        : %1d\n", m_nb_tx);
372     for (unsigned int i=0;i<m_nb_tx;i++) {
373         debugOutput(DEBUG_LEVEL_VERBOSE,"  Transmitter %d:\n",i);
374
375         readTxReg(i, DICE_REGISTER_TX_ISOC_BASE, &tmp_quadlet);
376         debugOutput(DEBUG_LEVEL_VERBOSE,"   ISO channel       : %3d\n", tmp_quadlet);
377         readTxReg(i, DICE_REGISTER_TX_SPEED_BASE, &tmp_quadlet);
378         debugOutput(DEBUG_LEVEL_VERBOSE,"   ISO speed         : %3d\n", tmp_quadlet);
379
380         readTxReg(i, DICE_REGISTER_TX_NB_AUDIO_BASE, &tmp_quadlet);
381         debugOutput(DEBUG_LEVEL_VERBOSE,"   Nb audio channels : %3d\n", tmp_quadlet);
382         readTxReg(i, DICE_REGISTER_TX_MIDI_BASE, &tmp_quadlet);
383         debugOutput(DEBUG_LEVEL_VERBOSE,"   Nb midi channels  : %3d\n", tmp_quadlet);
384
385         readTxReg(i, DICE_REGISTER_TX_AC3_CAPABILITIES_BASE, &tmp_quadlet);
386         debugOutput(DEBUG_LEVEL_VERBOSE,"   AC3 caps          : 0x%08X\n", tmp_quadlet);
387         readTxReg(i, DICE_REGISTER_TX_AC3_ENABLE_BASE, &tmp_quadlet);
388         debugOutput(DEBUG_LEVEL_VERBOSE,"   AC3 enable        : 0x%08X\n", tmp_quadlet);
389
390         diceNameVector channel_names=getTxNameString(i);
391         debugOutput(DEBUG_LEVEL_VERBOSE,"   Channel names     :\n");
392         for ( diceNameVectorIterator it = channel_names.begin();
393             it != channel_names.end();
394             ++it )
395         {
396             debugOutput(DEBUG_LEVEL_VERBOSE,"     %s\n", (*it).c_str());
397         }
398     }
399
400     debugOutput(DEBUG_LEVEL_VERBOSE," RX param space:\n");
401     debugOutput(DEBUG_LEVEL_VERBOSE,"  Nb of recv        : %1d\n", m_nb_tx);
402     for (unsigned int i=0;i<m_nb_rx;i++) {
403         debugOutput(DEBUG_LEVEL_VERBOSE,"  Receiver %d:\n",i);
404
405         readTxReg(i, DICE_REGISTER_RX_ISOC_BASE, &tmp_quadlet);
406         debugOutput(DEBUG_LEVEL_VERBOSE,"   ISO channel       : %3d\n", tmp_quadlet);
407         readTxReg(i, DICE_REGISTER_RX_SEQ_START_BASE, &tmp_quadlet);
408         debugOutput(DEBUG_LEVEL_VERBOSE,"   Sequence start    : %3d\n", tmp_quadlet);
409
410         readTxReg(i, DICE_REGISTER_RX_NB_AUDIO_BASE, &tmp_quadlet);
411         debugOutput(DEBUG_LEVEL_VERBOSE,"   Nb audio channels : %3d\n", tmp_quadlet);
412         readTxReg(i, DICE_REGISTER_RX_MIDI_BASE, &tmp_quadlet);
413         debugOutput(DEBUG_LEVEL_VERBOSE,"   Nb midi channels  : %3d\n", tmp_quadlet);
414
415         readTxReg(i, DICE_REGISTER_RX_AC3_CAPABILITIES_BASE, &tmp_quadlet);
416         debugOutput(DEBUG_LEVEL_VERBOSE,"   AC3 caps          : 0x%08X\n", tmp_quadlet);
417         readTxReg(i, DICE_REGISTER_RX_AC3_ENABLE_BASE, &tmp_quadlet);
418         debugOutput(DEBUG_LEVEL_VERBOSE,"   AC3 enable        : 0x%08X\n", tmp_quadlet);
419
420         diceNameVector channel_names=getRxNameString(i);
421         debugOutput(DEBUG_LEVEL_VERBOSE,"   Channel names     :\n");
422         for ( diceNameVectorIterator it = channel_names.begin();
423             it != channel_names.end();
424             ++it )
425         {
426             debugOutput(DEBUG_LEVEL_VERBOSE,"     %s\n", (*it).c_str());
427         }
428     }
429 }
430
431 // NOTE on bandwidth calculation
432 // FIXME: The bandwidth allocation calculation can probably be
433 // refined somewhat since this is currently based on a rudimentary
434 // understanding of the iso protocol.
435 // Currently we assume the following.
436 //   * Ack/iso gap = 0.05 us
437 //   * DATA_PREFIX = 0.16 us1
438 //   * DATA_END    = 0.26 us
439 // These numbers are the worst-case figures given in the ieee1394
440 // standard.  This gives approximately 0.5 us of overheads per
441 // packet - around 25 bandwidth allocation units (from the ieee1394
442 // standard 1 bandwidth allocation unit is 125/6144 us).  We further
443 // assume the device is running at S400 (which it should be) so one
444 // allocation unit is equivalent to 1 transmitted byte; thus the
445 // bandwidth allocation required for the packets themselves is just
446 // the size of the packet.
447 bool
448 DiceAvDevice::prepare() {
449     // prepare receive SP's
450 //     for (unsigned int i=0;i<m_nb_tx;i++) {
451     for (unsigned int i=0;i<1;i++) {
452         fb_quadlet_t nb_audio;
453         fb_quadlet_t nb_midi;
454         unsigned int nb_channels=0;
455
456         if(!readTxReg(i, DICE_REGISTER_TX_NB_AUDIO_BASE, &nb_audio)) {
457             debugError("Could not read DICE_REGISTER_TX_NB_AUDIO_BASE register for ATX%u",i);
458             continue;
459         }
460         if(!readTxReg(i, DICE_REGISTER_TX_MIDI_BASE, &nb_midi)) {
461             debugError("Could not read DICE_REGISTER_TX_MIDI_BASE register for ATX%u",i);
462             continue;
463         }
464
465         // request the channel names
466         diceNameVector names_audio=getTxNameString(i);
467
468         if (names_audio.size() != nb_audio) {
469             debugWarning("The audio channel name vector is incorrect, using default names\n");
470             names_audio.clear();
471
472             for (unsigned int j=0;j<nb_audio;j++) {
473                 std::ostringstream newname;
474                 newname << "input_" << j;
475                 names_audio.push_back(newname.str());
476             }
477         }
478
479         nb_channels=nb_audio;
480         if(nb_midi) nb_channels += 1; // midi-muxed counts as one
481
482         // construct the MIDI names
483         diceNameVector names_midi;
484         for (unsigned int j=0;j<nb_midi;j++) {
485             std::ostringstream newname;
486             newname << "midi_in_" << j;
487             names_midi.push_back(newname.str());
488         }
489
490         // construct the streamprocessor
491         Streaming::AmdtpReceiveStreamProcessor *p;
492         p=new Streaming::AmdtpReceiveStreamProcessor(
493                              m_p1394Service->getPort(),
494                              nb_channels);
495
496         if(!p->init()) {
497             debugFatal("Could not initialize receive processor!\n");
498             delete p;
499             continue;
500         }
501
502         // add audio ports to the processor
503         for (unsigned int j=0;j<nb_audio;j++) {
504             diceChannelInfo channelInfo;
505             channelInfo.name=names_audio.at(j);
506             channelInfo.portType=ePT_Analog;
507             channelInfo.streamPosition=j;
508             channelInfo.streamLocation=0;
509
510             if (!addChannelToProcessor(&channelInfo, p, Streaming::Port::E_Capture)) {
511                 debugError("Could not add channel %s to StreamProcessor\n",
512                     channelInfo.name.c_str());
513                 continue;
514             }
515         }
516
517         // add midi ports to the processor
518         for (unsigned int j=0;j<nb_midi;j++) {
519             diceChannelInfo channelInfo;
520             channelInfo.name=names_midi.at(j);
521             channelInfo.portType=ePT_MIDI;
522             channelInfo.streamPosition=nb_audio;
523             channelInfo.streamLocation=j;
524
525             if (!addChannelToProcessor(&channelInfo, p, Streaming::Port::E_Capture)) {
526                 debugError("Could not add channel %s to StreamProcessor\n",
527                     channelInfo.name.c_str());
528                 continue;
529             }
530         }
531
532         // add the SP to the vector
533         m_receiveProcessors.push_back(p);
534     }
535
536     // prepare transmit SP's
537 //     for (unsigned int i=0;i<m_nb_rx;i++) {
538     for (unsigned int i=0;i<1;i++) {
539         fb_quadlet_t nb_audio;
540         fb_quadlet_t nb_midi;
541         unsigned int nb_channels=0;
542
543         if(!readTxReg(i, DICE_REGISTER_RX_NB_AUDIO_BASE, &nb_audio)) {
544             debugError("Could not read DICE_REGISTER_RX_NB_AUDIO_BASE register for ARX%u",i);
545             continue;
546         }
547         if(!readTxReg(i, DICE_REGISTER_RX_MIDI_BASE, &nb_midi)) {
548             debugError("Could not read DICE_REGISTER_RX_MIDI_BASE register for ARX%u",i);
549             continue;
550         }
551
552         // request the channel names
553         diceNameVector names_audio=getRxNameString(i);
554
555         if (names_audio.size() != nb_audio) {
556             debugWarning("The audio channel name vector is incorrect, using default names\n");
557             names_audio.clear();
558
559             for (unsigned int j=0;j<nb_audio;j++) {
560                 std::ostringstream newname;
561                 newname << "output_" << j;
562                 names_audio.push_back(newname.str());
563             }
564         }
565
566         nb_channels=nb_audio;
567         if(nb_midi) nb_channels += 1; // midi-muxed counts as one
568
569         // construct the MIDI names
570         diceNameVector names_midi;
571         for (unsigned int j=0;j<nb_midi;j++) {
572             std::ostringstream newname;
573             newname << "midi_out_" << j;
574             names_midi.push_back(newname.str());
575         }
576
577         // construct the streamprocessor
578         Streaming::AmdtpTransmitStreamProcessor *p;
579         p=new Streaming::AmdtpTransmitStreamProcessor(
580                              m_p1394Service->getPort(),
581                              nb_channels);
582
583         if(!p->init()) {
584             debugFatal("Could not initialize transmit processor!\n");
585             delete p;
586             continue;
587         }
588
589         // add audio ports to the processor
590         for (unsigned int j=0;j<nb_audio;j++) {
591             diceChannelInfo channelInfo;
592             channelInfo.name=names_audio.at(j);
593             channelInfo.portType=ePT_Analog;
594             channelInfo.streamPosition=j;
595             channelInfo.streamLocation=0;
596
597             if (!addChannelToProcessor(&channelInfo, p, Streaming::Port::E_Playback)) {
598                 debugError("Could not add channel %s to StreamProcessor\n",
599                     channelInfo.name.c_str());
600                 continue;
601             }
602         }
603
604         // add midi ports to the processor
605         for (unsigned int j=0;j<nb_midi;j++) {
606             diceChannelInfo channelInfo;
607             channelInfo.name=names_midi.at(j);
608             channelInfo.portType=ePT_MIDI;
609             channelInfo.streamPosition=nb_audio;
610             channelInfo.streamLocation=j;
611
612             if (!addChannelToProcessor(&channelInfo, p, Streaming::Port::E_Playback)) {
613                 debugError("Could not add channel %s to StreamProcessor\n",
614                     channelInfo.name.c_str());
615                 continue;
616             }
617         }
618
619         m_transmitProcessors.push_back(p);
620     }
621     return true;
622 }
623
624 bool
625 DiceAvDevice::addChannelToProcessor(
626     diceChannelInfo *channelInfo,
627     Streaming::StreamProcessor *processor,
628     Streaming::Port::E_Direction direction) {
629
630     std::string id=std::string("dev?");
631     if(!getOption("id", id)) {
632         debugWarning("Could not retrieve id parameter, defauling to 'dev?'\n");
633     }
634
635     std::ostringstream portname;
636     portname << id;
637     if(direction == Streaming::Port::E_Playback) {
638         portname << "p";
639     } else {
640         portname << "c";
641     }
642
643     portname << "_" << channelInfo->name;
644
645     Streaming::Port *p=NULL;
646     switch(channelInfo->portType) {
647     case ePT_Analog:
648         p=new Streaming::AmdtpAudioPort(
649                 portname.str(),
650                 direction,
651                 channelInfo->streamPosition,
652                 channelInfo->streamLocation,
653                 Streaming::AmdtpPortInfo::E_MBLA
654         );
655         break;
656
657     case ePT_MIDI:
658         p=new Streaming::AmdtpMidiPort(
659                 portname.str(),
660                 direction,
661                 channelInfo->streamPosition,
662                 channelInfo->streamLocation,
663                 Streaming::AmdtpPortInfo::E_Midi
664         );
665
666         break;
667     default:
668     // unsupported
669         break;
670     }
671
672     if (!p) {
673         debugOutput(DEBUG_LEVEL_VERBOSE, "Skipped port %s\n",channelInfo->name.c_str());
674     } else {
675
676         if (!processor->addPort(p)) {
677             debugWarning("Could not register port with stream processor\n");
678             return false;
679         }
680     }
681
682     return true;
683 }
684
685 bool
686 DiceAvDevice::lock() {
687     fb_octlet_t result;
688
689     debugOutput(DEBUG_LEVEL_VERBOSE, "Locking %s %s at node %d\n",
690         m_model->vendor_name, m_model->model_name, getNodeId());
691
692     // get a notifier to handle device notifications
693     nodeaddr_t notify_address;
694     notify_address = m_p1394Service->findFreeARMBlock(
695                         DICE_NOTIFIER_BASE_ADDRESS,
696                         DICE_NOTIFIER_BLOCK_LENGTH,
697                         DICE_NOTIFIER_BLOCK_LENGTH);
698
699     if (notify_address == 0xFFFFFFFFFFFFFFFFLLU) {
700         debugError("Could not find free ARM block for notification\n");
701         return false;
702     }
703
704     m_notifier=new DiceAvDevice::DiceNotifier(this, notify_address);
705
706     if(!m_notifier) {
707         debugError("Could not allocate notifier\n");
708         return false;
709     }
710
711     if (!m_p1394Service->registerARMHandler(m_notifier)) {
712         debugError("Could not register notifier\n");
713         delete m_notifier;
714         m_notifier=NULL;
715         return false;
716     }
717
718     // register this notifier
719     fb_nodeaddr_t addr = DICE_REGISTER_BASE
720                        + m_global_reg_offset
721                        + DICE_REGISTER_GLOBAL_OWNER;
722
723     // registry offsets should always be smaller than 0x7FFFFFFF
724     // because otherwise base + offset > 64bit
725     if(m_global_reg_offset & 0x80000000) {
726         debugError("register offset not initialized yet\n");
727         return false;
728     }
729
730     fb_nodeaddr_t swap_value = ((0xFFC0) | m_p1394Service->getLocalNodeId());
731     swap_value = swap_value << 48;
732     swap_value |= m_notifier->getStart();
733
734     if (!m_p1394Service->lockCompareSwap64(  getNodeId() | 0xFFC0, addr, DICE_OWNER_NO_OWNER,
735                                        swap_value, &result )) {
736         debugWarning("Could not register ourselves as device owner\n");
737         return false;
738     }
739
740     if (result != DICE_OWNER_NO_OWNER) {
741         debugWarning("Could not register ourselves as device owner, unexpected register value: 0x%016llX\n", result);
742         return false;
743     }
744
745     return true;
746 }
747
748
749 bool
750 DiceAvDevice::unlock() {
751     fb_octlet_t result;
752
753     if(!m_notifier) {
754         debugWarning("Request to unlock, but no notifier present!\n");
755         return false;
756     }
757
758     fb_nodeaddr_t addr = DICE_REGISTER_BASE
759                        + m_global_reg_offset
760                        + DICE_REGISTER_GLOBAL_OWNER;
761
762     // registry offsets should always be smaller than 0x7FFFFFFF
763     // because otherwise base + offset > 64bit
764     if(m_global_reg_offset & 0x80000000) {
765         debugError("register offset not initialized yet\n");
766         return false;
767     }
768
769     fb_nodeaddr_t compare_value = ((0xFFC0) | m_p1394Service->getLocalNodeId());
770     compare_value <<= 48;
771     compare_value |= m_notifier->getStart();
772
773     if (!m_p1394Service->lockCompareSwap64(  getNodeId() | 0xFFC0, addr, compare_value,
774                                        DICE_OWNER_NO_OWNER, &result )) {
775         debugWarning("Could not unregister ourselves as device owner\n");
776         return false;
777     }
778
779     m_p1394Service->unregisterARMHandler(m_notifier);
780     delete m_notifier;
781     m_notifier=NULL;
782
783     return true;
784 }
785
786 bool
787 DiceAvDevice::enableStreaming() {
788     return enableIsoStreaming();
789 }
790
791 bool
792 DiceAvDevice::disableStreaming() {
793     return disableIsoStreaming();
794 }
795
796 int
797 DiceAvDevice::getStreamCount() {
798     return m_receiveProcessors.size() + m_transmitProcessors.size();
799 }
800
801 Streaming::StreamProcessor *
802 DiceAvDevice::getStreamProcessorByIndex(int i) {
803
804     if (i<(int)m_receiveProcessors.size()) {
805         return m_receiveProcessors.at(i);
806     } else if (i<(int)m_receiveProcessors.size() + (int)m_transmitProcessors.size()) {
807         return m_transmitProcessors.at(i-m_receiveProcessors.size());
808     }
809
810     return NULL;
811 }
812
813 bool
814 DiceAvDevice::startStreamByIndex(int i) {
815
816     if (isIsoStreamingEnabled()) {
817         debugError("Cannot start streams while streaming is enabled\n");
818         return false;
819     }
820
821     if (i<(int)m_receiveProcessors.size()) {
822         int n=i;
823         Streaming::StreamProcessor *p=m_receiveProcessors.at(n);
824
825         // allocate ISO channel
826         int isochannel=allocateIsoChannel(p->getMaxPacketSize());
827         if(isochannel<0) {
828             debugError("Could not allocate iso channel for SP %d (ATX %d)\n",i,n);
829             return false;
830         }
831         p->setChannel(isochannel);
832
833         fb_quadlet_t reg_isoch;
834         // check value of ISO_CHANNEL register
835         if(!readTxReg(n, DICE_REGISTER_TX_ISOC_BASE, &reg_isoch)) {
836             debugError("Could not read ISO_CHANNEL register for ATX %d\n", n);
837             p->setChannel(-1);
838             deallocateIsoChannel(isochannel);
839             return false;
840         }
841         if(reg_isoch != 0xFFFFFFFFUL) {
842             debugError("ISO_CHANNEL register != 0xFFFFFFFF (=0x%08X) for ATX %d\n", reg_isoch, n);
843             p->setChannel(-1);
844             deallocateIsoChannel(isochannel);
845             return false;
846         }
847
848         // write value of ISO_CHANNEL register
849         reg_isoch=isochannel;
850         if(!writeTxReg(n, DICE_REGISTER_TX_ISOC_BASE, reg_isoch)) {
851             debugError("Could not write ISO_CHANNEL register for ATX %d\n", n);
852             p->setChannel(-1);
853             deallocateIsoChannel(isochannel);
854             return false;
855         }
856
857         return true;
858
859     } else if (i<(int)m_receiveProcessors.size() + (int)m_transmitProcessors.size()) {
860         int n=i-m_receiveProcessors.size();
861         Streaming::StreamProcessor *p=m_transmitProcessors.at(n);
862
863         // allocate ISO channel
864         int isochannel=allocateIsoChannel(p->getMaxPacketSize());
865         if(isochannel<0) {
866             debugError("Could not allocate iso channel for SP %d (ATX %d)\n",i,n);
867             return false;
868         }
869         p->setChannel(isochannel);
870
871         fb_quadlet_t reg_isoch;
872         // check value of ISO_CHANNEL register
873         if(!readRxReg(n, DICE_REGISTER_RX_ISOC_BASE, &reg_isoch)) {
874             debugError("Could not read ISO_CHANNEL register for ARX %d\n", n);
875             p->setChannel(-1);
876             deallocateIsoChannel(isochannel);
877             return false;
878         }
879         if(reg_isoch != 0xFFFFFFFFUL) {
880             debugError("ISO_CHANNEL register != 0xFFFFFFFF (=0x%08X) for ARX %d\n", reg_isoch, n);
881             p->setChannel(-1);
882             deallocateIsoChannel(isochannel);
883             return false;
884         }
885
886         // write value of ISO_CHANNEL register
887         reg_isoch=isochannel;
888         if(!writeRxReg(n, DICE_REGISTER_RX_ISOC_BASE, reg_isoch)) {
889             debugError("Could not write ISO_CHANNEL register for ARX %d\n", n);
890             p->setChannel(-1);
891             deallocateIsoChannel(isochannel);
892             return false;
893         }
894
895         return true;
896     }
897
898     debugError("SP index %d out of range!\n",i);
899
900     return false;
901 }
902
903 bool
904 DiceAvDevice::stopStreamByIndex(int i) {
905
906     if (isIsoStreamingEnabled()) {
907         debugError("Cannot stop streams while streaming is enabled\n");
908         return false;
909     }
910
911     if (i<(int)m_receiveProcessors.size()) {
912         int n=i;
913         Streaming::StreamProcessor *p=m_receiveProcessors.at(n);
914         unsigned int isochannel=p->getChannel();
915
916         fb_quadlet_t reg_isoch;
917         // check value of ISO_CHANNEL register
918         if(!readTxReg(n, DICE_REGISTER_TX_ISOC_BASE, &reg_isoch)) {
919             debugError("Could not read ISO_CHANNEL register for ATX %d\n", n);
920             return false;
921         }
922         if(reg_isoch != isochannel) {
923             debugError("ISO_CHANNEL register != 0x%08X (=0x%08X) for ATX %d\n", isochannel, reg_isoch, n);
924             return false;
925         }
926
927         // write value of ISO_CHANNEL register
928         reg_isoch=0xFFFFFFFFUL;
929         if(!writeTxReg(n, DICE_REGISTER_TX_ISOC_BASE, reg_isoch)) {
930             debugError("Could not write ISO_CHANNEL register for ATX %d\n", n);
931             return false;
932         }
933
934         // deallocate ISO channel
935         if(!deallocateIsoChannel(isochannel)) {
936             debugError("Could not deallocate iso channel for SP %d (ATX %d)\n",i,n);
937             return false;
938         }
939
940         p->setChannel(-1);
941         return true;
942
943     } else if (i<(int)m_receiveProcessors.size() + (int)m_transmitProcessors.size()) {
944         int n=i-m_receiveProcessors.size();
945         Streaming::StreamProcessor *p=m_transmitProcessors.at(n);
946
947         unsigned int isochannel=p->getChannel();
948
949         fb_quadlet_t reg_isoch;
950         // check value of ISO_CHANNEL register
951         if(!readRxReg(n, DICE_REGISTER_RX_ISOC_BASE, &reg_isoch)) {
952             debugError("Could not read ISO_CHANNEL register for ARX %d\n", n);
953             return false;
954         }
955         if(reg_isoch != isochannel) {
956             debugError("ISO_CHANNEL register != 0x%08X (=0x%08X) for ARX %d\n", isochannel, reg_isoch, n);
957             return false;
958         }
959
960         // write value of ISO_CHANNEL register
961         reg_isoch=0xFFFFFFFFUL;
962         if(!writeRxReg(n, DICE_REGISTER_RX_ISOC_BASE, reg_isoch)) {
963             debugError("Could not write ISO_CHANNEL register for ARX %d\n", n);
964             return false;
965         }
966
967         // deallocate ISO channel
968         if(!deallocateIsoChannel(isochannel)) {
969             debugError("Could not deallocate iso channel for SP %d (ARX %d)\n",i,n);
970             return false;
971         }
972
973         p->setChannel(-1);
974         return true;
975     }
976
977     debugError("SP index %d out of range!\n",i);
978
979     return false;
980 }
981
982 // helper routines
983
984 // allocate ISO resources for the SP's
985 int DiceAvDevice::allocateIsoChannel(unsigned int packet_size) {
986     unsigned int bandwidth=8+packet_size;
987
988     int ch=m_p1394Service->allocateIsoChannelGeneric(bandwidth);
989
990     debugOutput(DEBUG_LEVEL_VERBOSE, "allocated channel %d, bandwidth %d\n",
991         ch, bandwidth);
992
993     return ch;
994 }
995 // deallocate ISO resources
996 bool DiceAvDevice::deallocateIsoChannel(int channel) {
997     debugOutput(DEBUG_LEVEL_VERBOSE, "freeing channel %d\n",channel);
998     return m_p1394Service->freeIsoChannel(channel);
999 }
1000
1001 bool
1002 DiceAvDevice::enableIsoStreaming() {
1003     return writeGlobalReg(DICE_REGISTER_GLOBAL_ENABLE, DICE_ISOSTREAMING_ENABLE);
1004 }
1005
1006 bool
1007 DiceAvDevice::disableIsoStreaming() {
1008     return writeGlobalReg(DICE_REGISTER_GLOBAL_ENABLE, DICE_ISOSTREAMING_DISABLE);
1009 }
1010
1011 bool
1012 DiceAvDevice::isIsoStreamingEnabled() {
1013     fb_quadlet_t result;
1014     readGlobalReg(DICE_REGISTER_GLOBAL_ENABLE, &result);
1015     // I don't know what exactly is 'enable',
1016     // but disable is definately == 0
1017     return (result != DICE_ISOSTREAMING_DISABLE);
1018 }
1019
1020 /**
1021  * @brief performs a masked bit register equals 0 check on the global parameter space
1022  * @return true if readGlobalReg(offset) & mask == 0
1023  */
1024 bool
1025 DiceAvDevice::maskedCheckZeroGlobalReg(fb_nodeaddr_t offset, fb_quadlet_t mask) {
1026     fb_quadlet_t result;
1027     readGlobalReg(offset, &result);
1028     return ((result & mask) == 0);
1029 }
1030 /**
1031  * @brief performs a masked bit register not equal to 0 check on the global parameter space
1032  * @return true if readGlobalReg(offset) & mask != 0
1033  */
1034 bool
1035 DiceAvDevice::maskedCheckNotZeroGlobalReg(fb_nodeaddr_t offset, fb_quadlet_t mask) {
1036     return !maskedCheckZeroGlobalReg(offset, mask);
1037 }
1038
1039 DiceAvDevice::diceNameVector
1040 DiceAvDevice::getTxNameString(unsigned int i) {
1041     diceNameVector names;
1042     char namestring[DICE_TX_NAMES_SIZE+1];
1043
1044     if (!readTxRegBlock(i, DICE_REGISTER_TX_NAMES_BASE,
1045                         (fb_quadlet_t *)namestring, DICE_TX_NAMES_SIZE)) {
1046         debugError("Could not read TX name string \n");
1047         return names;
1048     }
1049
1050     namestring[DICE_TX_NAMES_SIZE]='\0';
1051     return splitNameString(std::string(namestring));
1052 }
1053
1054 DiceAvDevice::diceNameVector
1055 DiceAvDevice::getRxNameString(unsigned int i) {
1056     diceNameVector names;
1057     char namestring[DICE_RX_NAMES_SIZE+1];
1058
1059     if (!readRxRegBlock(i, DICE_REGISTER_RX_NAMES_BASE,
1060                         (fb_quadlet_t *)namestring, DICE_RX_NAMES_SIZE)) {
1061         debugError("Could not read RX name string \n");
1062         return names;
1063     }
1064
1065     namestring[DICE_RX_NAMES_SIZE]='\0';
1066     return splitNameString(std::string(namestring));
1067 }
1068
1069 DiceAvDevice::diceNameVector
1070 DiceAvDevice::getClockSourceNameString() {
1071     diceNameVector names;
1072     char namestring[DICE_CLOCKSOURCENAMES_SIZE+1];
1073
1074     if (!readGlobalRegBlock(DICE_REGISTER_GLOBAL_CLOCKSOURCENAMES,
1075                         (fb_quadlet_t *)namestring, DICE_CLOCKSOURCENAMES_SIZE)) {
1076         debugError("Could not read CLOCKSOURCE name string \n");
1077         return names;
1078     }
1079
1080     namestring[DICE_CLOCKSOURCENAMES_SIZE]='\0';
1081     return splitNameString(std::string(namestring));
1082 }
1083
1084 std::string
1085 DiceAvDevice::getDeviceNickName() {
1086     char namestring[DICE_NICK_NAME_SIZE+1];
1087
1088     if (!readGlobalRegBlock(DICE_REGISTER_GLOBAL_NICK_NAME,
1089                         (fb_quadlet_t *)namestring, DICE_NICK_NAME_SIZE)) {
1090         debugError("Could not read nickname string \n");
1091         return std::string("(unknown)");
1092     }
1093
1094     namestring[DICE_NICK_NAME_SIZE]='\0';
1095     return std::string(namestring);
1096 }
1097
1098 DiceAvDevice::diceNameVector
1099 DiceAvDevice::splitNameString(std::string in) {
1100     diceNameVector names;
1101
1102     // find the end of the string
1103     unsigned int end=in.find(string("\\\\"));
1104     // cut the end
1105     in=in.substr(0,end);
1106
1107     unsigned int cut;
1108     while( (cut = in.find(string("\\"))) != in.npos ) {
1109         if(cut > 0) {
1110             names.push_back(in.substr(0,cut));
1111         }
1112         in = in.substr(cut+1);
1113     }
1114     if(in.length() > 0) {
1115         names.push_back(in);
1116     }
1117     return names;
1118 }
1119
1120
1121 // I/O routines
1122 bool
1123 DiceAvDevice::initIoFunctions() {
1124
1125     // offsets and sizes are returned in quadlets, but we use byte values
1126
1127     if(!readReg(DICE_REGISTER_GLOBAL_PAR_SPACE_OFF, &m_global_reg_offset)) {
1128         debugError("Could not initialize m_global_reg_offset\n");
1129         return false;
1130     }
1131     m_global_reg_offset*=4;
1132
1133     if(!readReg(DICE_REGISTER_GLOBAL_PAR_SPACE_SZ, &m_global_reg_size)) {
1134         debugError("Could not initialize m_global_reg_size\n");
1135         return false;
1136     }
1137     m_global_reg_size*=4;
1138
1139     if(!readReg(DICE_REGISTER_TX_PAR_SPACE_OFF, &m_tx_reg_offset)) {
1140         debugError("Could not initialize m_tx_reg_offset\n");
1141         return false;
1142     }
1143     m_tx_reg_offset*=4;
1144
1145     if(!readReg(DICE_REGISTER_TX_PAR_SPACE_SZ, &m_tx_reg_size)) {
1146         debugError("Could not initialize m_tx_reg_size\n");
1147         return false;
1148     }
1149     m_tx_reg_size*=4;
1150
1151     if(!readReg(DICE_REGISTER_RX_PAR_SPACE_OFF, &m_rx_reg_offset)) {
1152         debugError("Could not initialize m_rx_reg_offset\n");
1153         return false;
1154     }
1155     m_rx_reg_offset*=4;
1156
1157     if(!readReg(DICE_REGISTER_RX_PAR_SPACE_SZ, &m_rx_reg_size)) {
1158         debugError("Could not initialize m_rx_reg_size\n");
1159         return false;
1160     }
1161     m_rx_reg_size*=4;
1162
1163     if(!readReg(DICE_REGISTER_UNUSED1_SPACE_OFF, &m_unused1_reg_offset)) {
1164         debugError("Could not initialize m_unused1_reg_offset\n");
1165         return false;
1166     }
1167     m_unused1_reg_offset*=4;
1168
1169     if(!readReg(DICE_REGISTER_UNUSED1_SPACE_SZ, &m_unused1_reg_size)) {
1170         debugError("Could not initialize m_unused1_reg_size\n");
1171         return false;
1172     }
1173     m_unused1_reg_size*=4;
1174
1175     if(!readReg(DICE_REGISTER_UNUSED2_SPACE_OFF, &m_unused2_reg_offset)) {
1176         debugError("Could not initialize m_unused2_reg_offset\n");
1177         return false;
1178     }
1179     m_unused2_reg_offset*=4;
1180
1181     if(!readReg(DICE_REGISTER_UNUSED2_SPACE_SZ, &m_unused2_reg_size)) {
1182         debugError("Could not initialize m_unused2_reg_size\n");
1183         return false;
1184     }
1185     m_unused2_reg_size*=4;
1186
1187     if(!readReg(m_tx_reg_offset + DICE_REGISTER_TX_NB_TX, &m_nb_tx)) {
1188         debugError("Could not initialize m_nb_tx\n");
1189         return false;
1190     }
1191     if(!readReg(m_tx_reg_offset + DICE_REGISTER_TX_SZ_TX, &m_tx_size)) {
1192         debugError("Could not initialize m_tx_size\n");
1193         return false;
1194     }
1195     m_tx_size*=4;
1196
1197     if(!readReg(m_tx_reg_offset + DICE_REGISTER_RX_NB_RX, &m_nb_rx)) {
1198         debugError("Could not initialize m_nb_rx\n");
1199         return false;
1200     }
1201     if(!readReg(m_tx_reg_offset + DICE_REGISTER_RX_SZ_RX, &m_rx_size)) {
1202         debugError("Could not initialize m_rx_size\n");
1203         return false;
1204     }
1205     m_rx_size*=4;
1206
1207     debugOutput(DEBUG_LEVEL_VERBOSE,"DICE Parameter Space info:\n");
1208     debugOutput(DEBUG_LEVEL_VERBOSE," Global  : offset=%04X size=%04d\n", m_global_reg_offset, m_global_reg_size);
1209     debugOutput(DEBUG_LEVEL_VERBOSE," TX      : offset=%04X size=%04d\n", m_tx_reg_offset, m_tx_reg_size);
1210     debugOutput(DEBUG_LEVEL_VERBOSE,"               nb=%4d size=%04d\n", m_nb_tx, m_tx_size);
1211     debugOutput(DEBUG_LEVEL_VERBOSE," RX      : offset=%04X size=%04d\n", m_rx_reg_offset, m_rx_reg_size);
1212     debugOutput(DEBUG_LEVEL_VERBOSE,"               nb=%4d size=%04d\n", m_nb_rx, m_rx_size);
1213     debugOutput(DEBUG_LEVEL_VERBOSE," UNUSED1 : offset=%04X size=%04d\n", m_unused1_reg_offset, m_unused1_reg_size);
1214     debugOutput(DEBUG_LEVEL_VERBOSE," UNUSED2 : offset=%04X size=%04d\n", m_unused2_reg_offset, m_unused2_reg_size);
1215
1216     return true;
1217 }
1218
1219 bool
1220 DiceAvDevice::readReg(fb_nodeaddr_t offset, fb_quadlet_t *result) {
1221     debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Reading base register offset 0x%08llX\n", offset);
1222
1223     if(offset >= DICE_INVALID_OFFSET) {
1224         debugError("invalid offset: 0x%016llX\n", offset);
1225         return false;
1226     }
1227
1228     fb_nodeaddr_t addr=DICE_REGISTER_BASE + offset;
1229     fb_nodeid_t nodeId=getNodeId() | 0xFFC0;
1230
1231     if(!m_p1394Service->read_quadlet( nodeId, addr, result ) ) {
1232         debugError("Could not read from node 0x%04X addr 0x%012X\n", nodeId, addr);
1233         return false;
1234     }
1235
1236     *result=ntohl(*result);
1237
1238     debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Read result: 0x%08X\n", *result);
1239
1240     return true;
1241 }
1242
1243 bool
1244 DiceAvDevice::writeReg(fb_nodeaddr_t offset, fb_quadlet_t data) {
1245     debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Writing base register offset 0x%08llX, data: 0x%08X\n",
1246         offset, data);
1247
1248     if(offset >= DICE_INVALID_OFFSET) {
1249         debugError("invalid offset: 0x%016llX\n", offset);
1250         return false;
1251     }
1252
1253     fb_nodeaddr_t addr=DICE_REGISTER_BASE + offset;
1254     fb_nodeid_t nodeId=getNodeId() | 0xFFC0;
1255
1256     if(!m_p1394Service->write_quadlet( nodeId, addr, htonl(data) ) ) {
1257         debugError("Could not write to node 0x%04X addr 0x%012X\n", nodeId, addr);
1258         return false;
1259     }
1260     return true;
1261 }
1262
1263 bool
1264 DiceAvDevice::readRegBlock(fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length) {
1265     debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Reading base register offset 0x%08llX, length %u\n",
1266         offset, length);
1267
1268     if(offset >= DICE_INVALID_OFFSET) {
1269         debugError("invalid offset: 0x%016llX\n", offset);
1270         return false;
1271     }
1272
1273     fb_nodeaddr_t addr=DICE_REGISTER_BASE + offset;
1274     fb_nodeid_t nodeId=getNodeId() | 0xFFC0;
1275
1276     if(!m_p1394Service->read( nodeId, addr, length/4, data ) ) {
1277         debugError("Could not read from node 0x%04X addr 0x%012llX\n", nodeId, addr);
1278         return false;
1279     }
1280
1281     for(unsigned int i=0;i<length/4;i++) {
1282         *(data+i)=ntohl(*(data+i));
1283     }
1284
1285     return true;
1286 }
1287
1288 bool
1289 DiceAvDevice::writeRegBlock(fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length) {
1290     debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Writing base register offset 0x%08llX, length: %u\n",
1291         offset, length);
1292
1293     if(offset >= DICE_INVALID_OFFSET) {
1294         debugError("invalid offset: 0x%016llX\n", offset);
1295         return false;
1296     }
1297
1298     fb_nodeaddr_t addr=DICE_REGISTER_BASE + offset;
1299     fb_nodeid_t nodeId=getNodeId() | 0xFFC0;
1300
1301     fb_quadlet_t data_out[length/4];
1302
1303     for(unsigned int i=0;i<length/4;i++) {
1304         data_out[i]=ntohl(*(data+i));
1305     }
1306
1307     if(!m_p1394Service->write( nodeId, addr, length/4, data_out ) ) {
1308         debugError("Could not write to node 0x%04X addr 0x%012llX\n", nodeId, addr);
1309         return false;
1310     }
1311
1312     return true;
1313 }
1314
1315 bool
1316 DiceAvDevice::readGlobalReg(fb_nodeaddr_t offset, fb_quadlet_t *result) {
1317     debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Reading global register offset 0x%04llX\n", offset);
1318
1319     fb_nodeaddr_t offset_gl=globalOffsetGen(offset, sizeof(fb_quadlet_t));
1320     return readReg(m_global_reg_offset + offset_gl, result);
1321 }
1322
1323 bool
1324 DiceAvDevice::writeGlobalReg(fb_nodeaddr_t offset, fb_quadlet_t data) {
1325     debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Writing global register offset 0x%08llX, data: 0x%08X\n",
1326         offset, data);
1327
1328     fb_nodeaddr_t offset_gl=globalOffsetGen(offset, sizeof(fb_quadlet_t));
1329     return writeReg(m_global_reg_offset + offset_gl, data);
1330 }
1331
1332 bool
1333 DiceAvDevice::readGlobalRegBlock(fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length) {
1334     debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Reading global register block offset 0x%04llX, length %u bytes\n",
1335         offset, length);
1336
1337     fb_nodeaddr_t offset_gl=globalOffsetGen(offset, length);
1338     return readRegBlock(m_global_reg_offset + offset_gl, data, length);
1339 }
1340
1341 bool
1342 DiceAvDevice::writeGlobalRegBlock(fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length) {
1343     debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Writing global register block offset 0x%04llX, length %u bytes\n",
1344         offset, length);
1345
1346     fb_nodeaddr_t offset_gl=globalOffsetGen(offset, length);
1347     return writeRegBlock(m_global_reg_offset + offset_gl, data, length);
1348 }
1349
1350 fb_nodeaddr_t
1351 DiceAvDevice::globalOffsetGen(fb_nodeaddr_t offset, size_t length) {
1352
1353     // registry offsets should always be smaller than 0x7FFFFFFF
1354     // because otherwise base + offset > 64bit
1355     if(m_global_reg_offset & 0x80000000) {
1356         debugError("register offset not initialized yet\n");
1357         return DICE_INVALID_OFFSET;
1358     }
1359     // out-of-range check
1360     if(offset+length > m_global_reg_offset+m_global_reg_size) {
1361         debugError("register offset+length too large: 0x%0llX\n", offset + length);
1362         return DICE_INVALID_OFFSET;
1363     }
1364
1365     return offset;
1366 }
1367
1368 bool
1369 DiceAvDevice::readTxReg(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *result) {
1370     debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Reading tx %d register offset 0x%04llX\n", i, offset);
1371
1372     fb_nodeaddr_t offset_tx=txOffsetGen(i, offset, sizeof(fb_quadlet_t));
1373     return readReg(m_tx_reg_offset + offset_tx, result);
1374 }
1375
1376 bool
1377 DiceAvDevice::writeTxReg(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t data) {
1378     debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Writing tx %d register offset 0x%08llX, data: 0x%08X\n",
1379         i, offset, data);
1380
1381     fb_nodeaddr_t offset_tx=txOffsetGen(i, offset, sizeof(fb_quadlet_t));
1382     return writeReg(m_tx_reg_offset + offset_tx, data);
1383 }
1384
1385 bool
1386 DiceAvDevice::readTxRegBlock(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length) {
1387     debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Reading rx register block offset 0x%04llX, length %u bytes\n",
1388         offset, length);
1389
1390     fb_nodeaddr_t offset_tx=txOffsetGen(i, offset, length);
1391     return readRegBlock(m_tx_reg_offset + offset_tx, data, length);
1392 }
1393
1394 bool
1395 DiceAvDevice::writeTxRegBlock(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length) {
1396     debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Writing rx register block offset 0x%04llX, length %u bytes\n",
1397         offset, length);
1398
1399     fb_nodeaddr_t offset_tx=txOffsetGen(i, offset, length);
1400     return writeRegBlock(m_tx_reg_offset + offset_tx, data, length);
1401 }
1402
1403 fb_nodeaddr_t
1404 DiceAvDevice::txOffsetGen(unsigned int i, fb_nodeaddr_t offset, size_t length) {
1405     // registry offsets should always be smaller than 0x7FFFFFFF
1406     // because otherwise base + offset > 64bit
1407     if(m_tx_reg_offset & 0x80000000) {
1408         debugError("register offset not initialized yet\n");
1409         return DICE_INVALID_OFFSET;
1410     }
1411     if(m_nb_tx & 0x80000000) {
1412         debugError("m_nb_tx not initialized yet\n");
1413         return DICE_INVALID_OFFSET;
1414     }
1415     if(m_tx_size & 0x80000000) {
1416         debugError("m_tx_size not initialized yet\n");
1417         return DICE_INVALID_OFFSET;
1418     }
1419     if(i >= m_nb_tx) {
1420         debugError("TX index out of range\n");
1421         return DICE_INVALID_OFFSET;
1422     }
1423
1424     fb_nodeaddr_t offset_tx = DICE_REGISTER_TX_PARAM(m_tx_size, i, offset);
1425
1426     // out-of-range check
1427     if(offset_tx + length > m_tx_reg_offset+4+m_tx_reg_size*m_nb_tx) {
1428         debugError("register offset+length too large: 0x%0llX\n", offset_tx + length);
1429         return DICE_INVALID_OFFSET;
1430     }
1431
1432     return offset_tx;
1433 }
1434
1435 bool
1436 DiceAvDevice::readRxReg(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *result) {
1437     debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Reading rx %d register offset 0x%04llX\n", i, offset);
1438
1439     fb_nodeaddr_t offset_rx=rxOffsetGen(i, offset, sizeof(fb_quadlet_t));
1440     return readReg(m_rx_reg_offset + offset_rx, result);
1441 }
1442
1443 bool
1444 DiceAvDevice::writeRxReg(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t data) {
1445     debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Writing rx register offset 0x%08llX, data: 0x%08X\n",
1446         offset, data);
1447
1448     fb_nodeaddr_t offset_rx=rxOffsetGen(i, offset, sizeof(fb_quadlet_t));
1449     return writeReg(m_rx_reg_offset + offset_rx, data);
1450 }
1451
1452 bool
1453 DiceAvDevice::readRxRegBlock(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length) {
1454     debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Reading rx register block offset 0x%04llX, length %u bytes\n",
1455         offset, length);
1456
1457     fb_nodeaddr_t offset_rx=rxOffsetGen(i, offset, length);
1458     return readRegBlock(m_rx_reg_offset + offset_rx, data, length);
1459 }
1460
1461 bool
1462 DiceAvDevice::writeRxRegBlock(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length) {
1463     debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Writing rx register block offset 0x%04llX, length %u bytes\n",
1464         offset, length);
1465
1466     fb_nodeaddr_t offset_rx=rxOffsetGen(i, offset, length);
1467     return writeRegBlock(m_rx_reg_offset + offset_rx, data, length);
1468 }
1469
1470 fb_nodeaddr_t
1471 DiceAvDevice::rxOffsetGen(unsigned int i, fb_nodeaddr_t offset, size_t length) {
1472     // registry offsets should always be smaller than 0x7FFFFFFF
1473     // because otherwise base + offset > 64bit
1474     if(m_rx_reg_offset & 0x80000000) {
1475         debugError("register offset not initialized yet\n");
1476         return DICE_INVALID_OFFSET;
1477     }
1478     if(m_nb_rx & 0x80000000) {
1479         debugError("m_nb_rx not initialized yet\n");
1480         return DICE_INVALID_OFFSET;
1481     }
1482     if(m_rx_size & 0x80000000) {
1483         debugError("m_rx_size not initialized yet\n");
1484         return DICE_INVALID_OFFSET;
1485     }
1486     if(i >= m_nb_rx) {
1487         debugError("RX index out of range\n");
1488         return DICE_INVALID_OFFSET;
1489     }
1490
1491     fb_nodeaddr_t offset_rx = DICE_REGISTER_RX_PARAM(m_rx_size, i, offset);
1492
1493     // out-of-range check
1494     if(offset_rx + length > m_rx_reg_offset+4+m_rx_reg_size*m_nb_rx) {
1495         debugError("register offset+length too large: 0x%0llX\n", offset_rx + length);
1496         return DICE_INVALID_OFFSET;
1497     }
1498     return offset_rx;
1499 }
1500
1501
1502 // the notifier
1503
1504 DiceAvDevice::DiceNotifier::DiceNotifier(DiceAvDevice *d, nodeaddr_t start)
1505  : ARMHandler(start, DICE_NOTIFIER_BLOCK_LENGTH,
1506               RAW1394_ARM_READ | RAW1394_ARM_WRITE | RAW1394_ARM_LOCK,
1507               RAW1394_ARM_WRITE, 0)
1508  , m_dicedevice(d)
1509 {
1510
1511 }
1512
1513 DiceAvDevice::DiceNotifier::~DiceNotifier()
1514 {
1515
1516 }
1517
1518 }
Note: See TracBrowser for help on using the browser.