root/trunk/libffado/src/rme/rme_avdevice.cpp

Revision 2663, 44.7 kB (checked in by jwoithe, 7 years ago)

rme: move RME byteswap definitions into the header file to make them available to the streaming functions.

Line 
1 /*
2  * Copyright (C) 2005-2012 by Jonathan Woithe
3  * Copyright (C) 2005-2008 by Pieter Palmers
4  *
5  * This file is part of FFADO
6  * FFADO = Free Firewire (pro-)audio drivers for linux
7  *
8  * FFADO is based upon FreeBoB.
9  *
10  * This program is free software: you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation, either version 2 of the License, or
13  * (at your option) version 3 of the License.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
22  *
23  */
24
25 #include "config.h"
26
27 #include "rme/rme_avdevice.h"
28 #include "rme/fireface_def.h"
29 #include "rme/fireface_settings_ctrls.h"
30
31 #include "libieee1394/configrom.h"
32 #include "libieee1394/ieee1394service.h"
33 #include "libieee1394/IsoHandlerManager.h"
34
35 #include "debugmodule/debugmodule.h"
36
37 #include "libstreaming/rme/RmePort.h"
38
39 #include "devicemanager.h"
40
41 #include <string>
42 #include <stdint.h>
43 #include <assert.h>
44 #include <unistd.h>
45 #include "libutil/ByteSwap.h"
46
47 #include <iostream>
48 #include <sstream>
49
50 #include <libraw1394/csr.h>
51
52 // Known values for the unit version of RME devices
53 #define RME_UNITVERSION_FF800  0x0001
54 #define RME_UNITVERSION_FF400  0x0002
55 #define RME_UNITVERSION_UFX    0x0003
56 #define RME_UNITVERSION_UCX    0x0004
57
58 namespace Rme {
59
60 Device::Device( DeviceManager& d,
61                       std::auto_ptr<ConfigRom>( configRom ))
62     : FFADODevice( d, configRom )
63     , m_rme_model( RME_MODEL_NONE )
64     , settings( NULL )
65     , tco_settings( NULL )
66     , dev_config ( NULL )
67     , num_channels( 0 )
68     , frames_per_packet( 0 )
69     , speed800( 0 )
70     , provide_midi( 0 )
71     , iso_tx_channel( -1 )
72     , iso_rx_channel( -1 )
73     , m_receiveProcessor( NULL )
74     , m_transmitProcessor( NULL )
75     , m_MixerContainer( NULL )
76     , m_ControlContainer( NULL )
77 {
78     debugOutput( DEBUG_LEVEL_VERBOSE, "Created Rme::Device (NodeID %d)\n",
79                  getConfigRom().getNodeId() );
80 }
81
82 Device::~Device()
83 {
84     delete m_receiveProcessor;
85     delete m_transmitProcessor;
86
87     if (iso_tx_channel>=0 && !get1394Service().freeIsoChannel(iso_tx_channel)) {
88         debugOutput(DEBUG_LEVEL_VERBOSE, "Could not free tx iso channel %d\n", iso_tx_channel);
89     }
90     if (iso_rx_channel>=0 && m_rme_model==RME_MODEL_FIREFACE400 &&
91             !get1394Service().freeIsoChannel(iso_rx_channel)) {
92         // FF800 handles the rx channel itself
93         debugOutput(DEBUG_LEVEL_VERBOSE, "Could not free rx iso channel %d\n", iso_rx_channel);
94     }
95
96     destroyMixer();
97
98     if (dev_config != NULL) {
99         switch (rme_shm_close(dev_config)) {
100             case RSO_CLOSE:
101                 debugOutput( DEBUG_LEVEL_VERBOSE, "Configuration shared data object closed\n");
102                 break;
103             case RSO_CLOSE_DELETE:
104                 debugOutput( DEBUG_LEVEL_VERBOSE, "Configuration shared data object closed and deleted (no other users)\n");
105                 break;
106         }
107     }
108 }
109
110 bool
111 Device::buildMixer() {
112     signed int i;
113     bool result = true;
114
115     destroyMixer();
116     debugOutput(DEBUG_LEVEL_VERBOSE, "Building an RME mixer...\n");
117
118
119     // Non-mixer device controls
120     m_ControlContainer = new Control::Container(this, "Control");
121     if (!m_ControlContainer) {
122         debugError("Could not create control container\n");
123         destroyMixer();
124         return false;
125     }
126
127     result &= m_ControlContainer->addElement(
128         new RmeSettingsCtrl(*this, RME_CTRL_INFO_MODEL, 0,
129             "Model", "Model ID", ""));
130     result &= m_ControlContainer->addElement(
131         new RmeSettingsCtrl(*this, RME_CTRL_INFO_TCO_PRESENT, 0,
132             "TCO_present", "TCO is present", ""));
133     result &= m_ControlContainer->addElement(
134         new RmeSettingsCtrl(*this, RME_CTRL_INFO_SYSCLOCK_MODE, 0,
135             "sysclock_mode", "System clock mode", ""));
136     result &= m_ControlContainer->addElement(
137         new RmeSettingsCtrl(*this, RME_CTRL_INFO_SYSCLOCK_FREQ, 0,
138             "sysclock_freq", "System clock frequency", ""));
139     result &= m_ControlContainer->addElement(
140         new RmeSettingsCtrl(*this, RME_CTRL_INFO_AUTOSYNC_FREQ, 0,
141             "autosync_freq", "Autosync frequency", ""));
142     result &= m_ControlContainer->addElement(
143         new RmeSettingsCtrl(*this, RME_CTRL_INFO_AUTOSYNC_SRC, 0,
144             "autosync_src", "Autosync source", ""));
145     result &= m_ControlContainer->addElement(
146         new RmeSettingsCtrl(*this, RME_CTRL_INFO_SYNC_STATUS, 0,
147             "sync_status", "Sync status", ""));
148     result &= m_ControlContainer->addElement(
149         new RmeSettingsCtrl(*this, RME_CTRL_INFO_SPDIF_FREQ, 0,
150             "spdif_freq", "SPDIF frequency", ""));
151
152     result &= m_ControlContainer->addElement(
153         new RmeSettingsCtrl(*this, RME_CTRL_PHANTOM_SW, 0,
154             "Phantom", "Phantom switches", ""));
155     result &= m_ControlContainer->addElement(
156         new RmeSettingsCtrl(*this, RME_CTRL_INPUT_LEVEL, 0,
157             "Input_level", "Input level", ""));
158     result &= m_ControlContainer->addElement(
159         new RmeSettingsCtrl(*this, RME_CTRL_OUTPUT_LEVEL, 0,
160             "Output_level", "Output level", ""));
161     result &= m_ControlContainer->addElement(
162         new RmeSettingsCtrl(*this, RME_CTRL_SPDIF_INPUT_MODE, 0,
163             "SPDIF_input_mode", "SPDIF input mode", ""));
164     result &= m_ControlContainer->addElement(
165         new RmeSettingsCtrl(*this, RME_CTRL_SPDIF_OUTPUT_OPTICAL, 0,
166             "SPDIF_output_optical", "SPDIF output optical", ""));
167     result &= m_ControlContainer->addElement(
168         new RmeSettingsCtrl(*this, RME_CTRL_SPDIF_OUTPUT_EMPHASIS, 0,
169             "SPDIF_output_emphasis", "SPDIF output emphasis", ""));
170     result &= m_ControlContainer->addElement(
171         new RmeSettingsCtrl(*this, RME_CTRL_SPDIF_OUTPUT_PRO, 0,
172             "SPDIF_output_pro", "SPDIF output pro", ""));
173     result &= m_ControlContainer->addElement(
174         new RmeSettingsCtrl(*this, RME_CTRL_SPDIF_OUTPUT_NONAUDIO, 0,
175             "SPDIF_output_nonaudio", "SPDIF output non-audio", ""));
176     result &= m_ControlContainer->addElement(
177         new RmeSettingsCtrl(*this, RME_CTRL_PHONES_LEVEL, 0,
178             "Phones_level", "Phones level", ""));
179
180     result &= m_ControlContainer->addElement(
181         new RmeSettingsCtrl(*this, RME_CTRL_CLOCK_MODE, 0,
182             "Clock_mode", "Clock mode", ""));
183     result &= m_ControlContainer->addElement(
184         new RmeSettingsCtrl(*this, RME_CTRL_SYNC_REF, 0,
185             "Sync_ref", "Preferred sync ref", ""));
186     result &= m_ControlContainer->addElement(
187         new RmeSettingsCtrl(*this, RME_CTRL_LIMIT_BANDWIDTH, 0,
188             "Bandwidth_limit", "Bandwidth limit", ""));
189
190     result &= m_ControlContainer->addElement(
191         new RmeSettingsCtrl(*this, RME_CTRL_FLASH, 0,
192             "Flash_control", "Flash control", ""));
193     result &= m_ControlContainer->addElement(
194         new RmeSettingsCtrl(*this, RME_CTRL_MIXER_PRESET, 0,
195             "Mixer_preset", "Mixer preset", ""));
196
197     if (m_rme_model == RME_MODEL_FIREFACE800) {
198         result &= m_ControlContainer->addElement(
199             new RmeSettingsCtrl(*this, RME_CTRL_INPUT_SOURCE, 1,
200                 "Chan1_source", "Channel 1 source", ""));
201         result &= m_ControlContainer->addElement(
202             new RmeSettingsCtrl(*this, RME_CTRL_INPUT_SOURCE, 7,
203                 "Chan7_source", "Channel 7 source", ""));
204         result &= m_ControlContainer->addElement(
205             new RmeSettingsCtrl(*this, RME_CTRL_INPUT_SOURCE, 8,
206                 "Chan8_source", "Channel 8 source", ""));
207         result &= m_ControlContainer->addElement(
208             new RmeSettingsCtrl(*this, RME_CTRL_INSTRUMENT_OPTIONS, 1,
209                 "Chan1_instr_opts", "Input instrument options channel 1", ""));
210
211         result &= m_ControlContainer->addElement(
212             new RmeSettingsCtrl(*this, RME_CTRL_TCO_LTC_IN, 0,
213                 "Tco_ltc_in", "TCO input LTC received", ""));
214         result &= m_ControlContainer->addElement(
215             new RmeSettingsCtrl(*this, RME_CTRL_TCO_INPUT_LTC_VALID, 0,
216                 "Tco_input_ltc_valid", "TCO input LTC valid", ""));
217         result &= m_ControlContainer->addElement(
218             new RmeSettingsCtrl(*this, RME_CTRL_TCO_INPUT_LTC_FPS, 0,
219                 "Tco_input_ltc_fps", "TCO input LTC frame rate ID", ""));
220         result &= m_ControlContainer->addElement(
221             new RmeSettingsCtrl(*this, RME_CTRL_TCO_INPUT_LTC_DROPFRAME, 0,
222                 "Tco_input_ltc_dropframe", "TCO input LTC dropframe detected", ""));
223         result &= m_ControlContainer->addElement(
224             new RmeSettingsCtrl(*this, RME_CTRL_TCO_INPUT_VIDEO_TYPE, 0,
225                 "Tco_input_video_type", "TCO input video type", ""));
226         result &= m_ControlContainer->addElement(
227             new RmeSettingsCtrl(*this, RME_CTRL_TCO_INPUT_WORD_CLK, 0,
228                 "Tco_input_word_clk", "TCO input word clock type", ""));
229         result &= m_ControlContainer->addElement(
230             new RmeSettingsCtrl(*this, RME_CTRL_TCO_INPUT_LOCK, 0,
231                 "Tco_input_lock", "TCO input is locked", ""));
232         result &= m_ControlContainer->addElement(
233             new RmeSettingsCtrl(*this, RME_CTRL_TCO_SYNC_SRC, 0,
234                 "Tco_sync_src", "TCO sync source", ""));
235         result &= m_ControlContainer->addElement(
236             new RmeSettingsCtrl(*this, RME_CTRL_TCO_VIDEO_IN_TERM, 0,
237                 "Tco_video_in_term", "TCO video input terminator is enabled", ""));
238         result &= m_ControlContainer->addElement(
239             new RmeSettingsCtrl(*this, RME_CTRL_TCO_WORD_CLK_CONV, 0,
240                 "Tco_word_clk_conv", "TCO word clock conversion", ""));
241         result &= m_ControlContainer->addElement(
242             new RmeSettingsCtrl(*this, RME_CTRL_TCO_FREQ, 0,
243                 "Tco_freq", "TCO measured frequency (Hz)", ""));
244         result &= m_ControlContainer->addElement(
245             new RmeSettingsCtrl(*this, RME_CTRL_TCO_FRAME_RATE, 0,
246                 "Tco_frame_rate", "TCO frame rate ID", ""));
247         result &= m_ControlContainer->addElement(
248             new RmeSettingsCtrl(*this, RME_CTRL_TCO_SAMPLE_RATE, 0,
249                 "Tco_sample_rate", "TCO sample rate ID", ""));
250         result &= m_ControlContainer->addElement(
251             new RmeSettingsCtrl(*this, RME_CTRL_TCO_SAMPLE_RATE_OFS, 0,
252                 "Tco_sample_rate_ofs", "TCO sample rate pulldown offset ID", ""));
253     }
254
255     if (m_rme_model == RME_MODEL_FIREFACE400) {
256         // Instrument input options
257         for (i=3; i<=4; i++) {
258             char path[32], desc[64];
259             snprintf(path, sizeof(path), "Chan%d_opt_instr", i);
260             snprintf(desc, sizeof(desc), "Chan%d instrument option", i);
261             result &= m_ControlContainer->addElement(
262                 new RmeSettingsCtrl(*this, RME_CTRL_FF400_INSTR_SW, i,
263                     path, desc, ""));
264             snprintf(path, sizeof(path), "Chan%d_opt_pad", i);
265             snprintf(desc, sizeof(desc), "Chan%d pad option", i);
266             result &= m_ControlContainer->addElement(
267                 new RmeSettingsCtrl(*this, RME_CTRL_FF400_PAD_SW, i,
268                     path, desc, ""));
269         }
270
271         // Input/output gains
272         result &= m_ControlContainer->addElement(
273             new RmeSettingsMatrixCtrl(*this, RME_MATRIXCTRL_GAINS, "Gains"));
274     }
275
276     /* Mixer controls */
277     m_MixerContainer = new Control::Container(this, "Mixer");
278     if (!m_MixerContainer) {
279         debugError("Could not create mixer container\n");
280         destroyMixer();
281         return false;
282     }
283
284     result &= m_MixerContainer->addElement(
285         new RmeSettingsMatrixCtrl(*this, RME_MATRIXCTRL_INPUT_FADER, "InputFaders"));
286     result &= m_MixerContainer->addElement(
287         new RmeSettingsMatrixCtrl(*this, RME_MATRIXCTRL_PLAYBACK_FADER, "PlaybackFaders"));
288     result &= m_MixerContainer->addElement(
289         new RmeSettingsMatrixCtrl(*this, RME_MATRIXCTRL_OUTPUT_FADER, "OutputFaders"));
290     result &= m_MixerContainer->addElement(
291         new RmeSettingsMatrixCtrl(*this, RME_MATRIXCTRL_INPUT_MUTE, "InputMutes"));
292     result &= m_MixerContainer->addElement(
293         new RmeSettingsMatrixCtrl(*this, RME_MATRIXCTRL_PLAYBACK_MUTE, "PlaybackMutes"));
294     result &= m_MixerContainer->addElement(
295         new RmeSettingsMatrixCtrl(*this, RME_MATRIXCTRL_OUTPUT_MUTE, "OutputMutes"));
296     result &= m_MixerContainer->addElement(
297         new RmeSettingsMatrixCtrl(*this, RME_MATRIXCTRL_INPUT_INVERT, "InputInverts"));
298     result &= m_MixerContainer->addElement(
299         new RmeSettingsMatrixCtrl(*this, RME_MATRIXCTRL_PLAYBACK_INVERT, "PlaybackInverts"));
300
301     if (!result) {
302         debugWarning("One or more device control/mixer elements could not be created\n");
303         destroyMixer();
304         return false;
305     }
306
307     if (!addElement(m_ControlContainer) || !addElement(m_MixerContainer)) {
308         debugWarning("Could not register controls/mixer to device\n");
309         // clean up
310         destroyMixer();
311         return false;
312     }
313
314     return true;
315 }
316
317 bool
318 Device::destroyMixer() {
319     bool ret = true;
320     debugOutput(DEBUG_LEVEL_VERBOSE, "destroy mixer...\n");
321
322     if (m_MixerContainer == NULL) {
323         debugOutput(DEBUG_LEVEL_VERBOSE, "no mixer to destroy...\n");
324     } else
325     if (!deleteElement(m_MixerContainer)) {
326         debugError("Mixer present but not registered to the avdevice\n");
327         ret = false;
328     } else {
329         // remove and delete (as in free) child control elements
330         m_MixerContainer->clearElements(true);
331         delete m_MixerContainer;
332         m_MixerContainer = NULL;
333     }
334
335     // remove control container
336     if (m_ControlContainer == NULL) {
337         debugOutput(DEBUG_LEVEL_VERBOSE, "no controls to destroy...\n");
338     } else
339     if (!deleteElement(m_ControlContainer)) {
340         debugError("Controls present but not registered to the avdevice\n");
341         ret = false;
342     } else {
343         // remove and delete (as in free) child control elements
344         m_ControlContainer->clearElements(true);
345         delete m_ControlContainer;
346         m_ControlContainer = NULL;
347     }
348
349     return ret;
350 }
351
352 bool
353 Device::probe( Util::Configuration& c, ConfigRom& configRom, bool generic )
354 {
355     if (generic) {
356         return false;
357     } else {
358         // check if device is in supported devices list.  Note that the RME
359         // devices use the unit version to identify the individual devices.
360         // To avoid having to extend the configuration file syntax to
361         // include this at this point, we'll use the configuration file
362         // model ID to test against the device unit version.  This can be
363         // tidied up if the configuration file is extended at some point to
364         // include the unit version.
365         unsigned int vendorId = configRom.getNodeVendorId();
366         unsigned int unitVersion = configRom.getUnitVersion();
367
368         Util::Configuration::VendorModelEntry vme = c.findDeviceVME( vendorId, unitVersion );
369         return c.isValid(vme) && vme.driver == Util::Configuration::eD_RME;
370     }
371 }
372
373 FFADODevice *
374 Device::createDevice(DeviceManager& d, std::auto_ptr<ConfigRom>( configRom ))
375 {
376     return new Device(d, configRom );
377 }
378
379 bool
380 Device::discover()
381 {
382     signed int i;
383     std::string id;
384
385     unsigned int vendorId = getConfigRom().getNodeVendorId();
386     // See note in Device::probe() about why we use the unit version here.
387     unsigned int unitVersion = getConfigRom().getUnitVersion();
388
389     Util::Configuration &c = getDeviceManager().getConfiguration();
390     Util::Configuration::VendorModelEntry vme = c.findDeviceVME( vendorId, unitVersion );
391
392     if (c.isValid(vme) && vme.driver == Util::Configuration::eD_RME) {
393         debugOutput( DEBUG_LEVEL_VERBOSE, "found %s %s\n",
394                      vme.vendor_name.c_str(),
395                      vme.model_name.c_str());
396     } else {
397         debugWarning("Device '%s %s' unsupported by RME driver (no generic RME support)\n",
398                      getConfigRom().getVendorName().c_str(), getConfigRom().getModelName().c_str());
399     }
400
401     switch (unitVersion) {
402       case RME_UNITVERSION_FF800: m_rme_model = RME_MODEL_FIREFACE800; break;
403       case RME_UNITVERSION_FF400: m_rme_model = RME_MODEL_FIREFACE400; break;
404       case RME_UNITVERSION_UFX: m_rme_model = RME_MODEL_FIREFACE_UFX; break;
405       case RME_UNITVERSION_UCX: m_rme_model = RME_MODEL_FIREFACE_UCX; break;
406       default:
407         debugError("Unsupported model\n");
408         return false;
409     }
410
411     if (m_rme_model==RME_MODEL_FIREFACE_UFX || m_rme_model==RME_MODEL_FIREFACE_UCX) {
412       debugError("Fireface UFX/UCX are not currently supported\n");
413       return false;
414     }
415
416     id = std::string("dev0");
417     if (!getOption("id", id)) {
418         debugWarning("Could not retrieve id parameter, defaulting to 'dev0'\n");
419     }
420
421     // Set up the shared data object for configuration data
422     i = rme_shm_open(id, &dev_config);
423     if (i == RSO_OPEN_CREATED) {
424         debugOutput( DEBUG_LEVEL_VERBOSE, "New configuration shared data object created, ID %s\n", id.c_str());
425     } else
426     if (i == RSO_OPEN_ATTACHED) {
427         debugOutput( DEBUG_LEVEL_VERBOSE, "Attached to existing configuration shared data object for ID %s\n", id.c_str());
428     }
429     if (dev_config == NULL) {
430         debugOutput( DEBUG_LEVEL_WARNING, "Could not create/access shared configuration memory object, using process-local storage\n");
431         memset(&local_dev_config_obj, 0, sizeof(local_dev_config_obj));
432         dev_config = &local_dev_config_obj;
433     }
434     settings = &dev_config->settings;
435     tco_settings = &dev_config->tco_settings;
436
437     // If device is FF800, check to see if the TCO is fitted
438     if (m_rme_model == RME_MODEL_FIREFACE800) {
439         dev_config->tco_present = (read_tco(NULL, 0) == 0);
440     }
441     debugOutput(DEBUG_LEVEL_VERBOSE, "TCO present: %s\n",
442       dev_config->tco_present?"yes":"no");
443
444     init_hardware();
445
446     if (!buildMixer()) {
447         debugWarning("Could not build mixer\n");
448     }
449
450     return true;
451 }
452
453 int
454 Device::getSamplingFrequency( ) {
455
456     // Retrieve the current sample rate.  For practical purposes this
457     // is the software rate currently in use if in master clock mode, or
458     // the external clock if in slave mode.
459     //
460     // If dds_freq functionality is pursued, some thinking will be required
461     // here because the streaming engine will take its timings from the
462     // value returned by this function.  If the DDS is not running at
463     // software_freq, returning software_freq won't work for the streaming
464     // engine.  User software, on the other hand, would require the
465     // software_freq value.  Ultimately the streaming engine will probably
466     // have to be changed to obtain the "real" sample rate through other
467     // means.
468
469     // The kernel (as of 3.10 at least) seems to crash with an out-of-memory
470     // condition if this function calls get_hardware_state() too frequently
471     // (for example, several times per iso cycle).  The code of the RME
472     // driver should be structured in such a way as to prevent such calls
473     // from the fast path, but it's always possible that other components
474     // will call into this function when streaming is active (ffado-mixer
475     // for instance.  In such cases return the software frequency as a proxy
476     // for the true rate.
477
478     if (hardware_is_streaming()) {
479         return dev_config->software_freq;
480     }
481
482     FF_state_t state;
483     if (get_hardware_state(&state) != 0) {
484         debugOutput(DEBUG_LEVEL_ERROR, "failed to read device state\n");
485         return 0;
486     }
487     if (state.clock_mode == FF_STATE_CLOCKMODE_AUTOSYNC) {
488         // Note: this could return 0 if there is no valid external clock
489         return state.autosync_freq;
490     }
491
492     return dev_config->software_freq;
493 }
494
495 int
496 Device::getConfigurationId()
497 {
498     return 0;
499 }
500
501 bool
502 Device::setDDSFrequency( int dds_freq )
503 {
504     // Set a fixed DDS frequency.  If the device is the clock master this
505     // will immediately be copied to the hardware DDS register.  Otherwise
506     // it will take effect as required at the time the sampling rate is
507     // changed or streaming is started.
508
509     // If the device is streaming, the new DDS rate must have the same
510     // multiplier as the software sample rate.
511     //
512     // Since FFADO doesn't make use of the dds_freq functionality at present
513     // (there being no user access provided for this) the effect of changing
514     // the hardware DDS while streaming is active has not been tested.  A
515     // new DDS value will change the timestamp intervals applicable to the
516     // streaming engine, so an alteration here without at least a restart of
517     // the streaming will almost certainly cause trouble.  Initially it may
518     // be easiest to disallow such changes when streaming is active.
519     if (hardware_is_streaming()) {
520         if (multiplier_of_freq(dds_freq) != multiplier_of_freq(dev_config->software_freq))
521             return false;
522     }
523
524     dev_config->dds_freq = dds_freq;
525     if (settings->clock_mode == FF_STATE_CLOCKMODE_MASTER) {
526         if (set_hardware_dds_freq(dds_freq) != 0)
527             return false;
528     }
529
530     return true;
531 }
532
533 bool
534 Device::setSamplingFrequency( int samplingFrequency )
535 {
536     // Request a sampling rate on behalf of software.  Software is limited
537     // to sample rates of 32k, 44.1k, 48k and the 2x/4x multiples of these.
538     // The user may lock the device to a much wider range of frequencies via
539     // the explicit DDS controls in the control panel.  If the explicit DDS
540     // control is active the software is limited to the "standard" speeds
541     // corresponding to the multiplier in use by the DDS.
542     //
543     // Similarly, if the device is externally clocked the software is
544     // limited to the external clock frequency.
545     //
546     // Otherwise the software has free choice of the software speeds noted
547     // above.
548
549     bool ret = false;
550     signed int i, j;
551     signed int mult[3] = {1, 2, 4};
552     unsigned int base_freq[3] = {32000, 44100, 48000};
553     unsigned int freq = samplingFrequency;
554     FF_state_t state;
555     signed int fixed_freq = 0;
556
557     if (get_hardware_state(&state) != 0) {
558           debugOutput(DEBUG_LEVEL_ERROR, "failed to read device state\n");
559           return false;
560     }
561
562     // If device is locked to a frequency via external clock, explicit
563     // setting of the DDS or by virtue of streaming being active, get that
564     // frequency.
565     if (state.clock_mode == FF_STATE_CLOCKMODE_AUTOSYNC) {
566         // The autosync frequency can be retrieved from state.autosync_freq.
567         // An autosync_freq value of 0 indicates the absence of a valid
568         // external clock.  Allow sampling frequencies which match the
569         // sync rate and reject all others.
570         //
571         // A further note: if synced to TCO, is autosync_freq valid?
572         if (state.autosync_freq == 0) {
573             debugOutput(DEBUG_LEVEL_ERROR, "slave clock mode active but no valid external clock present\n");
574         }
575         if (state.autosync_freq==0 || (int)state.autosync_freq!=samplingFrequency)
576             return false;
577         dev_config->software_freq = samplingFrequency;
578         return true;
579     } else
580     if (dev_config->dds_freq > 0) {
581         fixed_freq = dev_config->dds_freq;
582     } else
583     if (hardware_is_streaming()) {
584         // See comments in getSamplingFrequency() as to why this may not
585         // be successful in the long run.
586         fixed_freq = dev_config->software_freq;
587     }
588
589     // If the device is running to a fixed frequency, software can only
590     // request frequencies with the same multiplier.  Similarly, the
591     // multiplier is locked in "master" clock mode if the device is
592     // streaming.
593     if (fixed_freq > 0) {
594         unsigned int fixed_mult = multiplier_of_freq(fixed_freq);
595         if (multiplier_of_freq(freq) != fixed_mult) {
596             debugOutput(DEBUG_LEVEL_ERROR, "DDS currently set to %d Hz, new sampling rate %d does not have the same multiplier\n",
597               fixed_freq, freq);
598             return false;
599         }
600         for (j=0; j<3; j++) {
601             if (freq == base_freq[j]*fixed_mult) {
602                 ret = true;
603                 break;
604             }
605         }
606     } else {
607         for (i=0; i<3; i++) {
608             for (j=0; j<3; j++) {
609                 if (freq == base_freq[j]*mult[i]) {
610                     ret = true;
611                     break;
612                 }
613             }
614         }
615     }
616     // If requested frequency is unavailable, return false
617     if (ret == false) {
618         debugOutput(DEBUG_LEVEL_ERROR, "requested sampling rate %d Hz not available\n", freq);
619         return false;
620     }
621
622     // If a DDS frequency has been explicitly requested this is always used
623     // to program the hardware DDS regardless of the rate requested by the
624     // software (such use of the DDS is only possible if the Fireface is
625     // operating in master clock mode).  Otherwise we use the requested
626     // sampling rate.
627     if (dev_config->dds_freq>0 && state.clock_mode==FF_STATE_CLOCKMODE_MASTER)
628         freq = dev_config->dds_freq;
629     if (set_hardware_dds_freq(freq) != 0) {
630         debugOutput(DEBUG_LEVEL_ERROR, "failed to set hardware sample rate to %d Hz\n", freq);
631         return false;
632     }
633
634     debugOutput(DEBUG_LEVEL_VERBOSE, "hardware set to sampling frequency %d Hz\n", samplingFrequency);
635     dev_config->software_freq = samplingFrequency;
636     settings->sample_rate = samplingFrequency;
637     return true;
638 }
639
640 std::vector<int>
641 Device::getSupportedSamplingFrequencies()
642 {
643     std::vector<int> frequencies;
644     signed int i, j;
645     signed int mult[3] = {1, 2, 4};
646     signed int freq[3] = {32000, 44100, 48000};
647     FF_state_t state;
648
649     if (get_hardware_state(&state) != 0) {
650         debugOutput(DEBUG_LEVEL_ERROR, "failed to read device state\n");
651         return frequencies;
652     }
653
654     // Generate the list of supported frequencies.  If the device is
655     // externally clocked the frequency is limited to the external clock
656     // frequency.
657     if (state.clock_mode == FF_STATE_CLOCKMODE_AUTOSYNC) {
658         // FIXME: if synced to TCO, is autosync_freq valid?
659         // The autosync frequency will be zero if no valid clock is available
660         frequencies.push_back(state.autosync_freq);
661     } else
662     // If the device is running the multiplier is fixed.
663     if (state.is_streaming) {
664         // It's not certain that permitting rate changes while streaming
665         // is active will work.  See comments in setSamplingFrequency() and
666         // elsewhere.
667         unsigned int fixed_mult = multiplier_of_freq(dev_config->software_freq);
668         for (j=0; j<3; j++) {
669             frequencies.push_back(freq[j]*fixed_mult);
670         }
671     } else {
672         for (i=0; i<3; i++) {
673             for (j=0; j<3; j++) {
674                 frequencies.push_back(freq[j]*mult[i]);
675             }
676         }
677     }
678     return frequencies;
679 }
680
681 // The RME clock source selection logic is a little more complex than a
682 // simple list can cater for.  Therefore we just put in a placeholder and
683 // rely on the extended controls in ffado-mixer to deal with the details.
684 //
685 FFADODevice::ClockSource
686 Device::dummyClockSource(void) {
687     ClockSource s;
688     s.id = 0;
689     s.type = eCT_Internal;
690     s.description = "Selected via device controls";
691     s.valid = s.active = s.locked = true;
692     s.slipping = false;
693     return s;
694 }
695 FFADODevice::ClockSourceVector
696 Device::getSupportedClockSources() {
697     FFADODevice::ClockSourceVector r;
698     ClockSource s;
699     s = dummyClockSource();
700     r.push_back(s);
701     return r;
702 }
703 bool
704 Device::setActiveClockSource(ClockSource s) {
705     return true;
706 }
707 FFADODevice::ClockSource
708 Device::getActiveClockSource() {
709     return dummyClockSource();
710 }
711
712 bool
713 Device::lock() {
714
715     return true;
716 }
717
718
719 bool
720 Device::unlock() {
721
722     return true;
723 }
724
725 void
726 Device::showDevice()
727 {
728     unsigned int vendorId = getConfigRom().getNodeVendorId();
729     unsigned int modelId = getConfigRom().getModelId();
730
731     Util::Configuration &c = getDeviceManager().getConfiguration();
732     Util::Configuration::VendorModelEntry vme = c.findDeviceVME( vendorId, modelId );
733
734     debugOutput(DEBUG_LEVEL_VERBOSE,
735         "%s %s at node %d\n", vme.vendor_name.c_str(), vme.model_name.c_str(), getNodeId());
736 }
737
738 bool
739 Device::resetForStreaming() {
740     signed int err;
741
742     signed int iso_rx;
743     unsigned int stat[4];
744     signed int i;
745
746     // Ensure the transmit processor is ready to start streaming.  When
747     // this function is called from prepare() the transmit processor
748     // won't be allocated.
749     if (m_transmitProcessor != NULL)
750         m_transmitProcessor->resetForStreaming();
751
752     // Whenever streaming is restarted hardware_init_streaming() needs to be
753     // called.  Otherwise the device won't start sending data when data is
754     // sent to it and the rx stream will fail to start.
755     err = hardware_init_streaming(dev_config->hardware_freq, iso_tx_channel) != 0;
756     if (err) {
757         debugFatal("Could not intialise device streaming system\n");
758         return false;
759     }
760
761     i = 0;
762     while (i < 100) {
763         err = (get_hardware_streaming_status(stat, 4) != 0);
764         if (err) {
765             debugFatal("error reading status register\n");
766             break;
767         }
768
769         debugOutput(DEBUG_LEVEL_VERBOSE, "rme init stat: %08x %08x %08x %08x\n",
770             stat[0], stat[1], stat[2], stat[3]);
771
772         if (m_rme_model == RME_MODEL_FIREFACE400) {
773             break;
774         }
775
776         // The Fireface-800 chooses its tx channel (our rx channel).  Wait
777         // for the device busy flag to clear, then confirm that the rx iso
778         // channel hasn't changed (it shouldn't across a restart).
779         if (stat[2] == 0xffffffff) {
780             // Device not ready; wait 5 ms and try again
781             usleep(5000);
782             i++;
783         } else {
784             iso_rx = stat[2] & 63;
785             if (iso_rx!=iso_rx_channel && iso_rx_channel!=-1)
786                 debugOutput(DEBUG_LEVEL_WARNING, "rx iso: now %d, was %d\n",
787                     iso_rx, iso_rx_channel);
788             iso_rx_channel = iso_rx;
789
790             // Even if the rx channel has changed, the device takes care of
791             // registering the channel itself, so we don't have to (neither
792             // do we have to release the old one).  If we try to call
793             // raw1394_channel_modify() on the returned channel we'll get an
794             // error.
795             //   iso_rx_channel = get1394Service().allocateFixedIsoChannelGeneric(iso_rx_channel, bandwidth);
796             break;
797         }
798     }
799     if (i==100 || err) {
800         if (i == 100)
801             debugFatal("timeout waiting for device not busy\n");
802         return false;
803     } else {
804         signed int init_samplerate;
805         if ((stat[1] & SR1_CLOCK_MODE_MASTER) ||
806             (stat[0] & SR0_AUTOSYNC_FREQ_MASK)==0 ||
807             (stat[0] & SR0_AUTOSYNC_SRC_MASK)==SR0_AUTOSYNC_SRC_NONE) {
808             init_samplerate = dev_config->hardware_freq;
809         } else {
810             init_samplerate = (stat[0] & SR0_STREAMING_FREQ_MASK) * 250;
811         }
812         debugOutput(DEBUG_LEVEL_VERBOSE, "sample rate on start: %d\n",
813             init_samplerate);
814     }
815
816     return FFADODevice::resetForStreaming();
817 }
818
819 bool
820 Device::prepare() {
821
822     signed int mult, bandwidth;
823     signed int freq;
824     signed int err = 0;
825
826     debugOutput(DEBUG_LEVEL_NORMAL, "Preparing Device...\n" );
827
828     // If there is no iso data to send in a given cycle the RMEs simply
829     // don't send anything.  This is in contrast to most other interfaces
830     // which at least send an empty packet.  As a result the IsoHandler
831     // contains code which detects missing packets as dropped packets.
832     // For RME devices we must turn this test off since missing packets
833     // are in fact to be expected.
834     get1394Service().getIsoHandlerManager().setMissedCyclesOK(true);
835
836     freq = getSamplingFrequency();
837     if (freq <= 0) {
838         debugOutput(DEBUG_LEVEL_ERROR, "Can't continue: sampling frequency not set\n");
839         return false;
840     }
841     mult = freq<68100?1:(freq<136200?2:4);
842
843     frames_per_packet = getFramesPerPacket();
844
845     // The number of active channels depends on sample rate and whether
846     // bandwidth limitation is active.  First set up the number of analog
847     // channels (which differs between devices), then add SPDIF channels if
848     // relevant.  Finally, the number of channels available from each ADAT
849     // interface depends on sample rate: 0 at 4x, 4 at 2x and 8 at 1x.
850     //  Note that "analog only" bandwidth limit mode means analog 1-8
851     // regardless of the fireface model in use.
852     if (m_rme_model==RME_MODEL_FIREFACE800 && settings->limit_bandwidth!=FF_SWPARAM_BWLIMIT_ANALOG_ONLY)
853         num_channels = 10;
854     else
855         num_channels = 8;
856     if (settings->limit_bandwidth != FF_SWPARAM_BWLIMIT_ANALOG_ONLY)
857         num_channels += 2;
858     if (settings->limit_bandwidth==FF_SWPARAM_BWLIMIT_SEND_ALL_CHANNELS ||
859         settings->limit_bandwidth==FF_DEV_FLASH_BWLIMIT_NO_ADAT2)
860         num_channels += (mult==4?0:(mult==2?4:8));
861     if (m_rme_model==RME_MODEL_FIREFACE800 &&
862         settings->limit_bandwidth==FF_SWPARAM_BWLIMIT_SEND_ALL_CHANNELS)
863         num_channels += (mult==4?0:(mult==2?4:8));
864
865     // Bandwidth is calculated here.  For the moment we assume the device
866     // is connected at S400, so 1 allocation unit is 1 transmitted byte.
867     // There is 25 allocation units of protocol overhead per packet.  Each
868     // channel of audio data is sent/received as a 32 bit integer.
869     bandwidth = 25 + num_channels*4*frames_per_packet;
870
871     // Both the FF400 and FF800 require we allocate a tx iso channel and
872     // then initialise the device.  Device status is then read at least once
873     // regardless of which interface is in use.  The rx channel is then
874     // allocated for the FF400 or acquired from the device in the case of
875     // the FF800.  Even though the FF800 chooses the rx channel it does not
876     // handle the bus-level channel/bandwidth allocation so we must do that
877     // here.
878     if (iso_tx_channel < 0) {
879         iso_tx_channel = get1394Service().allocateIsoChannelGeneric(bandwidth);
880     }
881     if (iso_tx_channel < 0) {
882         debugFatal("Could not allocate iso tx channel\n");
883         return false;
884     } else {
885       debugOutput(DEBUG_LEVEL_NORMAL, "iso tx channel: %d\n", iso_tx_channel);
886     }
887
888     // Call this to initialise the device's streaming system and, in the
889     // case of the FF800, obtain the rx iso channel to use.  Having that
890     // functionality in resetForStreaming() means it's effectively done
891     // twice when FFADO is first started, but this does no harm.
892     if (resetForStreaming() == false)
893         return false;
894  
895     if (err) {
896         if (iso_tx_channel >= 0)
897             get1394Service().freeIsoChannel(iso_tx_channel);
898         if (iso_rx_channel>=0 && m_rme_model==RME_MODEL_FIREFACE400)
899             // The FF800 manages this channel itself.
900             get1394Service().freeIsoChannel(iso_rx_channel);
901         return false;
902     }
903
904     /* We need to manage the FF400's iso rx channel */
905     if (m_rme_model == RME_MODEL_FIREFACE400) {
906         iso_rx_channel = get1394Service().allocateIsoChannelGeneric(bandwidth);
907     }
908
909     // get the device specific and/or global SP configuration
910     Util::Configuration &config = getDeviceManager().getConfiguration();
911     // base value is the config.h value
912     float recv_sp_dll_bw = STREAMPROCESSOR_DLL_BW_HZ;
913     float xmit_sp_dll_bw = STREAMPROCESSOR_DLL_BW_HZ;
914
915     // we can override that globally
916     config.getValueForSetting("streaming.spm.recv_sp_dll_bw", recv_sp_dll_bw);
917     config.getValueForSetting("streaming.spm.xmit_sp_dll_bw", xmit_sp_dll_bw);
918
919     // or override in the device section
920     config.getValueForDeviceSetting(getConfigRom().getNodeVendorId(), getConfigRom().getModelId(), "recv_sp_dll_bw", recv_sp_dll_bw);
921     config.getValueForDeviceSetting(getConfigRom().getNodeVendorId(), getConfigRom().getModelId(), "xmit_sp_dll_bw", xmit_sp_dll_bw);
922
923     // Calculate the event size.  Each audio channel is allocated 4 bytes in
924     // the data stream.
925     /* FIXME: this will still require fine-tuning, but it's a start */
926     signed int event_size = num_channels * 4;
927
928     // Set up receive stream processor, initialise it and set DLL bw
929     m_receiveProcessor = new Streaming::RmeReceiveStreamProcessor(*this,
930       m_rme_model, event_size);
931     m_receiveProcessor->setVerboseLevel(getDebugLevel());
932     if (!m_receiveProcessor->init()) {
933         debugFatal("Could not initialize receive processor!\n");
934         return false;
935     }
936     if (!m_receiveProcessor->setDllBandwidth(recv_sp_dll_bw)) {
937         debugFatal("Could not set DLL bandwidth\n");
938         delete m_receiveProcessor;
939         m_receiveProcessor = NULL;
940         return false;
941     }
942
943     // Add ports to the processor - TODO
944     std::string id=std::string("dev?");
945     if (!getOption("id", id)) {
946         debugWarning("Could not retrieve id parameter, defaulting to 'dev?'\n");
947     }
948     addDirPorts(Streaming::Port::E_Capture);
949
950     /* Now set up the transmit stream processor */
951     m_transmitProcessor = new Streaming::RmeTransmitStreamProcessor(*this,
952       m_rme_model, event_size);
953     m_transmitProcessor->setVerboseLevel(getDebugLevel());
954     if (!m_transmitProcessor->init()) {
955         debugFatal("Could not initialise receive processor!\n");
956         return false;
957     }
958     if (!m_transmitProcessor->setDllBandwidth(xmit_sp_dll_bw)) {
959         debugFatal("Could not set DLL bandwidth\n");
960         delete m_transmitProcessor;
961         m_transmitProcessor = NULL;
962         return false;
963     }
964
965     // Other things to be done:
966     //  * add ports to transmit stream processor
967     addDirPorts(Streaming::Port::E_Playback);
968
969     return true;
970 }
971
972 int
973 Device::getStreamCount() {
974     return 2; // one receive, one transmit
975 }
976
977 Streaming::StreamProcessor *
978 Device::getStreamProcessorByIndex(int i) {
979     switch (i) {
980         case 0:
981             return m_receiveProcessor;
982         case 1:
983             return m_transmitProcessor;
984         default:
985             debugWarning("Invalid stream index %d\n", i);
986     }
987     return NULL;
988 }
989
990 enum FFADODevice::eStreamingState
991 Device::getStreamingState() {
992   if (hardware_is_streaming())
993     return eSS_Both;
994   return eSS_Idle;
995 }
996
997 bool
998 Device::startStreamByIndex(int i) {
999     // The RME does not allow separate enabling of the transmit and receive
1000     // streams.  Therefore we start all streaming when index 0 is referenced
1001     // and silently ignore the start requests for other streams
1002     // (unconditionally flagging them as being successful).
1003     if (i == 0) {
1004         m_receiveProcessor->setChannel(iso_rx_channel);
1005         m_transmitProcessor->setChannel(iso_tx_channel);
1006         if (hardware_start_streaming(iso_rx_channel) != 0)
1007             return false;
1008     }
1009     return true;
1010 }
1011
1012 bool
1013 Device::stopStreamByIndex(int i) {
1014     // See comments in startStreamByIndex() as to why we act only when stream
1015     // 0 is requested.
1016     if (i == 0) {
1017         if (hardware_stop_streaming() != 0)
1018             return false;
1019     }
1020     return true;
1021 }
1022
1023 signed int
1024 Device::getFramesPerPacket(void) {
1025     // The number of frames transmitted in a single packet is solely
1026     // determined by the sample rate.  This function is called several times
1027     // per iso cycle by the tx stream processor, so use the software rate as
1028     // a proxy for the hardware sample rate.  Calling getSamplingFrequency()
1029     // is best avoided because otherwise the kernel tends to crash having
1030     // run out of memory (something about the timing of async commands in
1031     // getSamplingFrequency() and the iso tx handler seems to be tripping it
1032     // up).
1033     //
1034     // If streaming is active the software sampling rate should be set up.
1035     // If the dds_freq functionality is implemented the software rate can
1036     // probably still be used because the hardware dictates that both
1037     // must share the same multiplier, and the only reason for obtaining
1038     // the sampling frequency is to determine the multiplier.
1039     signed int freq = dev_config->software_freq;
1040     signed int mult = multiplier_of_freq(freq);
1041     switch (mult) {
1042         case 2: return 15;
1043         case 4: return 25;
1044     default:
1045         return 7;
1046     }
1047     return 7;
1048 }
1049
1050 bool
1051 Device::addPort(Streaming::StreamProcessor *s_processor,
1052     char *name, enum Streaming::Port::E_Direction direction,
1053     int position, int size) {
1054
1055     Streaming::Port *p;
1056     p = new Streaming::RmeAudioPort(*s_processor, name, direction, position, size);
1057     if (p == NULL) {
1058         debugOutput(DEBUG_LEVEL_VERBOSE, "Skipped port %s\n",name);
1059     }
1060     return true;
1061 }
1062
1063 bool
1064 Device::addDirPorts(enum Streaming::Port::E_Direction direction) {
1065
1066     const char *mode_str = direction==Streaming::Port::E_Capture?"cap":"pbk";
1067     Streaming::StreamProcessor *s_processor;
1068     std::string id;
1069     char name[128];
1070     signed int i;
1071     signed int n_analog, n_phones, n_adat, n_spdif;
1072     signed int sample_rate = getSamplingFrequency();
1073
1074     /* Apply bandwidth limit if selected.  This effectively sets up the
1075      * number of adat and spdif channels assuming single-rate speed.
1076      * The total number of expected analog channels is also set here.
1077      */
1078     n_spdif = 2;
1079     n_analog = (m_rme_model==RME_MODEL_FIREFACE800)?10:8;
1080     switch (dev_config->settings.limit_bandwidth) {
1081       case FF_SWPARAM_BWLIMIT_ANALOG_ONLY:
1082         n_adat = n_spdif = 0;
1083         // "Analog only" means "Analog 1-8" regardless of the interface model
1084         n_analog = 8;
1085         break;
1086       case FF_SWPARAM_BWLIMIT_ANALOG_SPDIF_ONLY:
1087         n_adat = 0;
1088         break;
1089       case FF_SWPARAM_BWLIMIT_NO_ADAT2:
1090         /* FF800 only */
1091         n_adat = 8;
1092         break;
1093       default:
1094         /* Send all channels */
1095         n_adat = (m_rme_model==RME_MODEL_FIREFACE800)?16:8;
1096     }
1097
1098     /* Adjust the spdif and ADAT channels according to the current sample
1099      * rate.
1100      */
1101     if (sample_rate>=MIN_DOUBLE_SPEED && sample_rate<MIN_QUAD_SPEED) {
1102       n_adat /= 2;
1103     } else
1104     if (sample_rate >= MIN_QUAD_SPEED) {
1105       n_adat = 0;
1106     }
1107
1108     n_phones = 0;
1109     if (direction == Streaming::Port::E_Capture) {
1110         s_processor = m_receiveProcessor;
1111     } else {
1112         s_processor = m_transmitProcessor;
1113         /* Phones generally count as two of the analog outputs.  For
1114          * the FF800 in "Analog 1-8" bandwidth limit mode this is
1115          * not the case and the phones are inactive.
1116          */
1117         if (m_rme_model==RME_MODEL_FIREFACE400 || dev_config->settings.limit_bandwidth!=FF_SWPARAM_BWLIMIT_ANALOG_ONLY) {
1118             n_analog -= 2;
1119             n_phones = 2;
1120         }
1121     }
1122
1123     id = std::string("dev?");
1124     if (!getOption("id", id)) {
1125         debugWarning("Could not retrieve id parameter, defaulting to 'dev?'\n");
1126     }
1127
1128     for (i=0; i<n_analog; i++) {
1129       snprintf(name, sizeof(name), "%s_%s_analog-%d", id.c_str(), mode_str, i+1);
1130       addPort(s_processor, name, direction, i*4, 0);
1131     }
1132     for (i=0; i<n_phones; i++) {
1133       snprintf(name, sizeof(name), "%s_%s_phones-%c", id.c_str(), mode_str,
1134         i==0?'L':'R');
1135       /* The headphone channels follow the straight analog lines */
1136       addPort(s_processor, name, direction, n_analog*4+i*4, 0);
1137     }
1138     for (i=0; i<n_spdif; i++) {
1139       snprintf(name, sizeof(name), "%s_%s_SPDIF-%d", id.c_str(), mode_str, i+1);
1140       /* The SPDIF channels start after all analog lines */
1141       addPort(s_processor, name, direction, (n_analog+n_phones)*4+i*4, 0);
1142     }
1143     for (i=0; i<n_adat; i++) {
1144       snprintf(name, sizeof(name), "%s_%s_adat-%d", id.c_str(), mode_str, i+1);
1145       /* ADAT ports follow all other ports */
1146       addPort(s_processor, name, direction, (n_analog+n_phones+n_spdif)*4+i*4, 0);
1147     }
1148
1149     return true;
1150 }
1151
1152 unsigned int
1153 Device::readRegister(fb_nodeaddr_t reg) {
1154
1155     quadlet_t quadlet;
1156    
1157     quadlet = 0;
1158     if (get1394Service().read(0xffc0 | getNodeId(), reg, 1, &quadlet) <= 0) {
1159         debugError("Error doing RME read from register 0x%06" PRIx64 "\n",reg);
1160     }
1161     return ByteSwapFromDevice32(quadlet);
1162 }
1163
1164 signed int
1165 Device::readBlock(fb_nodeaddr_t reg, quadlet_t *buf, unsigned int n_quads) {
1166
1167     unsigned int i;
1168
1169     if (get1394Service().read(0xffc0 | getNodeId(), reg, n_quads, buf) <= 0) {
1170         debugError("Error doing RME block read of %d quadlets from register 0x%06" PRIx64 "\n",
1171             n_quads, reg);
1172         return -1;
1173     }
1174     for (i=0; i<n_quads; i++) {
1175        buf[i] = ByteSwapFromDevice32(buf[i]);
1176     }
1177
1178     return 0;
1179 }
1180
1181 signed int
1182 Device::writeRegister(fb_nodeaddr_t reg, quadlet_t data) {
1183
1184     unsigned int err = 0;
1185     data = ByteSwapToDevice32(data);
1186     if (get1394Service().write(0xffc0 | getNodeId(), reg, 1, &data) <= 0) {
1187         err = 1;
1188         debugError("Error doing RME write to register 0x%06" PRIx64 "\n",reg);
1189     }
1190
1191     return (err==0)?0:-1;
1192 }
1193
1194 signed int
1195 Device::writeBlock(fb_nodeaddr_t reg, quadlet_t *data, unsigned int n_quads) {
1196 //
1197 // Write a block of data to the device starting at address "reg".  Note that
1198 // the conditional byteswap is done "in place" on data, so the contents of
1199 // data may be modified by calling this function.
1200 //
1201     unsigned int err = 0;
1202     unsigned int i;
1203
1204     for (i=0; i<n_quads; i++) {
1205       data[i] = ByteSwapToDevice32(data[i]);
1206     }
1207     if (get1394Service().write(0xffc0 | getNodeId(), reg, n_quads, data) <= 0) {
1208         err = 1;
1209         debugError("Error doing RME block write of %d quadlets to register 0x%06" PRIx64 "\n",
1210           n_quads, reg);
1211     }
1212
1213     return (err==0)?0:-1;
1214 }
1215                  
1216 }
Note: See TracBrowser for help on using the browser.