focusrite_saffirepro.cpp

Revision 864, 33.8 kB (checked in by ppalmers, 15 years ago)
update license to GPLv2 or GPLv3 instead of GPLv2 or any later version. Update copyrights to reflect the new year

Line
1	/*
2	* Copyright (C) 2005-2008 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 program is free software: you can redistribute it and/or modify
10	* it under the terms of the GNU General Public License as published by
11	* the Free Software Foundation, either version 2 of the License, or
12	* (at your option) version 3 of the License.
13	*
14	* This program is distributed in the hope that it will be useful,
15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	* GNU General Public License for more details.
18	*
19	* You should have received a copy of the GNU General Public License
20	* along with this program. If not, see <http://www.gnu.org/licenses/>.
21	*
22	*/
23
24	#include "focusrite_saffirepro.h"
25	#include "focusrite_cmd.h"
26
27	#include "libutil/Time.h"
28
29	namespace BeBoB {
30	namespace Focusrite {
31
32	SaffireProDevice::SaffireProDevice( DeviceManager& d, std::auto_ptr<ConfigRom>( configRom ))
33	: FocusriteDevice( d, configRom )
34	, m_MixerContainer( NULL )
35	, m_ControlContainer( NULL )
36	{
37	debugOutput( DEBUG_LEVEL_VERBOSE, "Created BeBoB::Focusrite::SaffireProDevice (NodeID %d)\n",
38	getConfigRom().getNodeId() );
39
40	addOption(Util::OptionContainer::Option("rebootOnSamplerateChange", true));
41	// the saffire pro doesn't seem to like it if the commands are too fast
42	if (AVC::AVCCommand::getSleepAfterAVCCommand() < 500) {
43	AVC::AVCCommand::setSleepAfterAVCCommand( 500 );
44	}
45	}
46
47	SaffireProDevice::~SaffireProDevice()
48	{
49	destroyMixer();
50	}
51
52	bool
53	SaffireProDevice::buildMixer()
54	{
55	bool result=true;
56	debugOutput(DEBUG_LEVEL_VERBOSE, "Building a Focusrite SaffirePro mixer...\n");
57
58	destroyMixer();
59
60	// create the mixer object container
61	m_MixerContainer = new Control::Container("Mixer");
62
63	if (!m_MixerContainer) {
64	debugError("Could not create mixer container...\n");
65	return false;
66	}
67
68	// output mute controls
69	result &= m_MixerContainer->addElement(
70	new BinaryControl(*this,
71	FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT12, FR_SAFFIREPRO_CMD_BITFIELD_BIT_MUTE,
72	"Out12Mute", "Out1/2 Mute", "Output 1/2 Mute"));
73	result &= m_MixerContainer->addElement(
74	new BinaryControl(*this,
75	FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT34, FR_SAFFIREPRO_CMD_BITFIELD_BIT_MUTE,
76	"Out34Mute", "Out3/4 Mute", "Output 3/4 Mute"));
77	result &= m_MixerContainer->addElement(
78	new BinaryControl(*this,
79	FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT56, FR_SAFFIREPRO_CMD_BITFIELD_BIT_MUTE,
80	"Out56Mute", "Out5/6 Mute", "Output 5/6 Mute"));
81	result &= m_MixerContainer->addElement(
82	new BinaryControl(*this,
83	FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT78, FR_SAFFIREPRO_CMD_BITFIELD_BIT_MUTE,
84	"Out78Mute", "Out7/8 Mute", "Output 7/8 Mute"));
85
86	// output front panel hw volume control
87	result &= m_MixerContainer->addElement(
88	new BinaryControl(*this,
89	FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT12, FR_SAFFIREPRO_CMD_BITFIELD_BIT_HWCTRL,
90	"Out12HwCtrl", "Out1/2 HwCtrl", "Output 1/2 Front Panel Hardware volume control"));
91	result &= m_MixerContainer->addElement(
92	new BinaryControl(*this,
93	FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT34, FR_SAFFIREPRO_CMD_BITFIELD_BIT_HWCTRL,
94	"Out34HwCtrl", "Out3/4 HwCtrl", "Output 3/4 Front Panel Hardware volume control"));
95	result &= m_MixerContainer->addElement(
96	new BinaryControl(*this,
97	FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT56, FR_SAFFIREPRO_CMD_BITFIELD_BIT_HWCTRL,
98	"Out56HwCtrl", "Out5/6 HwCtrl", "Output 5/6 Front Panel Hardware volume control"));
99	result &= m_MixerContainer->addElement(
100	new BinaryControl(*this,
101	FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT78, FR_SAFFIREPRO_CMD_BITFIELD_BIT_HWCTRL,
102	"Out78HwCtrl", "Out7/8 HwCtrl", "Output 7/8 Front Panel Hardware volume control"));
103
104	// output active monitor padding
105	result &= m_MixerContainer->addElement(
106	new BinaryControl(*this,
107	FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT12, FR_SAFFIREPRO_CMD_BITFIELD_BIT_PAD,
108	"Out12Pad", "Out1/2 Pad", "Output 1/2 Active Monitor Pad"));
109	result &= m_MixerContainer->addElement(
110	new BinaryControl(*this,
111	FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT34, FR_SAFFIREPRO_CMD_BITFIELD_BIT_PAD,
112	"Out34Pad", "Out3/4 Pad", "Output 3/4 Active Monitor Pad"));
113	result &= m_MixerContainer->addElement(
114	new BinaryControl(*this,
115	FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT56, FR_SAFFIREPRO_CMD_BITFIELD_BIT_PAD,
116	"Out56Pad", "Out5/6 Pad", "Output 5/6 Active Monitor Pad"));
117	result &= m_MixerContainer->addElement(
118	new BinaryControl(*this,
119	FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT78, FR_SAFFIREPRO_CMD_BITFIELD_BIT_PAD,
120	"Out78Pad", "Out7/8 Pad", "Output 7/8 Active Monitor Pad"));
121
122	// output level dim
123	result &= m_MixerContainer->addElement(
124	new BinaryControl(*this,
125	FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT12, FR_SAFFIREPRO_CMD_BITFIELD_BIT_DIM,
126	"Out12Dim", "Out1/2 Dim", "Output 1/2 Level Dim"));
127	result &= m_MixerContainer->addElement(
128	new BinaryControl(*this,
129	FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT34, FR_SAFFIREPRO_CMD_BITFIELD_BIT_DIM,
130	"Out34Dim", "Out3/4 Dim", "Output 3/4 Level Dim"));
131	result &= m_MixerContainer->addElement(
132	new BinaryControl(*this,
133	FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT56, FR_SAFFIREPRO_CMD_BITFIELD_BIT_DIM,
134	"Out56Dim", "Out5/6 Dim", "Output 5/6 Level Dim"));
135	result &= m_MixerContainer->addElement(
136	new BinaryControl(*this,
137	FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT78, FR_SAFFIREPRO_CMD_BITFIELD_BIT_DIM,
138	"Out78Dim", "Out7/8 Dim", "Output 7/8 Level Dim"));
139
140	// output level controls
141	result &= m_MixerContainer->addElement(
142	new VolumeControlLowRes(*this,
143	FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT12, 0,
144	"Out12Level", "Out1/2 Level", "Output 1/2 Level"));
145	result &= m_MixerContainer->addElement(
146	new VolumeControlLowRes(*this,
147	FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT34, 0,
148	"Out34Level", "Out3/4 Level", "Output 3/4 Level"));
149	result &= m_MixerContainer->addElement(
150	new VolumeControlLowRes(*this,
151	FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT56, 0,
152	"Out56Level", "Out5/6 Level", "Output 5/6 Level"));
153	result &= m_MixerContainer->addElement(
154	new VolumeControlLowRes(*this,
155	FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT78, 0,
156	"Out78Level", "Out7/8 Level", "Output 7/8 Level"));
157
158	// indicators
159	result &= m_MixerContainer->addElement(
160	new BinaryControl(*this,
161	FR_SAFFIREPRO_CMD_ID_MUTE_INDICATOR, 0,
162	"Out12MuteInd", "Out1/2 Mute Ind", "Output 1/2 Mute Indicator"));
163
164	result &= m_MixerContainer->addElement(
165	new BinaryControl(*this,
166	FR_SAFFIREPRO_CMD_ID_DIM_INDICATOR, 0,
167	"Out12DimInd", "Out1/2 Dim Ind", "Output 1/2 Level Dim Indicator"));
168
169	// matrix mix controls
170	result &= m_MixerContainer->addElement(
171	new SaffireProMatrixMixer(*this, SaffireProMatrixMixer::eMMT_InputMix, "InputMix"));
172
173	result &= m_MixerContainer->addElement(
174	new SaffireProMatrixMixer(*this, SaffireProMatrixMixer::eMMT_OutputMix, "OutputMix"));
175
176	if (!result) {
177	debugWarning("One or more mixer control elements could not be created.");
178	// clean up those that couldn't be created
179	destroyMixer();
180	return false;
181	}
182	if (!addElement(m_MixerContainer)) {
183	debugWarning("Could not register mixer to device\n");
184	// clean up
185	destroyMixer();
186	return false;
187	}
188
189	// special controls
190	m_ControlContainer = new Control::Container("Control");
191	if (!m_ControlContainer) {
192	debugError("Could not create mixer container...\n");
193	return false;
194	}
195
196	// create control objects for the saffire pro
197	result &= m_ControlContainer->addElement(
198	new BinaryControl(*this, FR_SAFFIREPRO_CMD_ID_PHANTOM14, 0,
199	"Phantom_1to4", "Phantom 1-4", "Switch Phantom Power on channels 1-4"));
200
201	result &= m_ControlContainer->addElement(
202	new BinaryControl(*this, FR_SAFFIREPRO_CMD_ID_PHANTOM58, 0,
203	"Phantom_5to8", "Phantom 5-8", "Switch Phantom Power on channels 5-8"));
204
205	result &= m_ControlContainer->addElement(
206	new BinaryControl(*this, FR_SAFFIREPRO_CMD_ID_INSERT1, 0,
207	"Insert1", "Insert 1", "Switch Insert on Channel 1"));
208
209	result &= m_ControlContainer->addElement(
210	new BinaryControl(*this, FR_SAFFIREPRO_CMD_ID_INSERT2, 0,
211	"Insert2", "Insert 2", "Switch Insert on Channel 2"));
212
213	result &= m_ControlContainer->addElement(
214	new BinaryControl(*this, FR_SAFFIREPRO_CMD_ID_AC3_PASSTHROUGH, 0,
215	"AC3pass", "AC3 Passtrough", "Enable AC3 Passthrough"));
216
217	result &= m_ControlContainer->addElement(
218	new BinaryControl(*this, FR_SAFFIREPRO_CMD_ID_MIDI_TRU, 0,
219	"MidiTru", "Midi Tru", "Enable Midi Tru"));
220
221	result &= m_ControlContainer->addElement(
222	new SaffireProMultiControl(*this, SaffireProMultiControl::eTCT_Reboot,
223	"Reboot", "Reboot", "Reboot Device"));
224
225	result &= m_ControlContainer->addElement(
226	new SaffireProMultiControl(*this, SaffireProMultiControl::eTCT_FlashLed,
227	"FlashLed", "Flash Led", "Flash power led"));
228
229	result &= m_ControlContainer->addElement(
230	new SaffireProMultiControl(*this, SaffireProMultiControl::eTCT_UseHighVoltageRail,
231	"UseHighVoltageRail", "Use High Supply", "Prefer the high voltage power supply rail"));
232
233	result &= m_ControlContainer->addElement(
234	new SaffireProMultiControl(*this, SaffireProMultiControl::eTCT_ExitStandalone,
235	"ExitStandalone", "Exit Standalone mode", "Try to leave standalonbe mode"));
236
237	result &= m_ControlContainer->addElement(
238	new SaffireProMultiControl(*this, SaffireProMultiControl::eTCT_PllLockRange,
239	"PllLockRange", "PLL Lock Range", "Get/Set PLL Lock range"));
240
241	if (!result) {
242	debugWarning("One or more device control elements could not be created.");
243	// clean up those that couldn't be created
244	destroyMixer();
245	return false;
246	}
247	if (!addElement(m_ControlContainer)) {
248	debugWarning("Could not register controls to device\n");
249	// clean up
250	destroyMixer();
251	return false;
252	}
253
254
255	return true;
256	}
257
258	bool
259	SaffireProDevice::destroyMixer()
260	{
261	debugOutput(DEBUG_LEVEL_VERBOSE, "destroy mixer...\n");
262
263	if (m_MixerContainer == NULL) {
264	debugOutput(DEBUG_LEVEL_VERBOSE, "no mixer to destroy...\n");
265	return true;
266	}
267
268	if (!deleteElement(m_MixerContainer)) {
269	debugError("Mixer present but not registered to the avdevice\n");
270	return false;
271	}
272
273	// remove and delete (as in free) child control elements
274	m_MixerContainer->clearElements(true);
275	delete m_MixerContainer;
276	m_MixerContainer = NULL;
277
278	// remove control container
279	if (m_ControlContainer == NULL) {
280	debugOutput(DEBUG_LEVEL_VERBOSE, "no controls to destroy...\n");
281	return true;
282	}
283
284	if (!deleteElement(m_ControlContainer)) {
285	debugError("Controls present but not registered to the avdevice\n");
286	return false;
287	}
288
289	// remove and delete (as in free) child control elements
290	m_ControlContainer->clearElements(true);
291	delete m_ControlContainer;
292	m_ControlContainer = NULL;
293
294	return true;
295	}
296
297	void
298	SaffireProDevice::showDevice()
299	{
300	debugOutput(DEBUG_LEVEL_VERBOSE, "This is a BeBoB::Focusrite::SaffireProDevice\n");
301	FocusriteDevice::showDevice();
302	}
303
304	void
305	SaffireProDevice::setVerboseLevel(int l)
306	{
307	debugOutput( DEBUG_LEVEL_VERBOSE, "Setting verbose level to %d...\n", l );
308
309	if (m_MixerContainer) m_MixerContainer->setVerboseLevel(l);
310
311	// FIXME: add the other elements here too
312
313	FocusriteDevice::setVerboseLevel(l);
314	}
315
316	int
317	SaffireProDevice::getSamplingFrequency( ) {
318	uint32_t sr;
319	if ( !getSpecificValue(FR_SAFFIREPRO_CMD_ID_SAMPLERATE, &sr ) ) {
320	debugError( "getSpecificValue failed\n" );
321	return 0;
322	}
323
324	debugOutput( DEBUG_LEVEL_VERBOSE,
325	"getSampleRate: %d\n", sr );
326
327	return convertDefToSr(sr);
328	}
329
330	bool
331	SaffireProDevice::setSamplingFrequencyDo( uint32_t value )
332	{
333	if ( !setSpecificValue(FR_SAFFIREPRO_CMD_ID_SAMPLERATE, value) ) {
334	debugError( "setSpecificValue failed\n" );
335	return false;
336	}
337	return true;
338	}
339
340	bool
341	SaffireProDevice::setSamplingFrequencyDoNoReboot( uint32_t value )
342	{
343	if ( !setSpecificValue(FR_SAFFIREPRO_CMD_ID_SAMPLERATE_NOREBOOT, value) ) {
344	debugError( "setSpecificValue failed\n" );
345	return false;
346	}
347	return true;
348	}
349
350	bool
351	SaffireProDevice::setSamplingFrequency( int s )
352	{
353	bool snoopMode=false;
354	if(!getOption("snoopMode", snoopMode)) {
355	debugWarning("Could not retrieve snoopMode parameter, defauling to false\n");
356	}
357
358	bool rebootOnSamplerateChange=false;
359	if(!getOption("rebootOnSamplerateChange", rebootOnSamplerateChange)) {
360	debugWarning("Could not retrieve rebootOnSamplerateChange parameter, defauling to false\n");
361	}
362
363	if(snoopMode) {
364	if (s != getSamplingFrequency()) {
365	debugError("In snoop mode it is impossible to set the sample rate.\n");
366	debugError("Please start the client with the correct setting.\n");
367	return false;
368	}
369	return true;
370	} else {
371	uint32_t value = convertSrToDef(s);
372	if ( value == 0 ) {
373	debugError("Unsupported samplerate: %u\n", s);
374	return false;
375	}
376
377	if (s == getSamplingFrequency()) {
378	debugOutput( DEBUG_LEVEL_VERBOSE, "No need to change samplerate\n");
379	return true;
380	}
381
382	const int max_tries = 2;
383	int ntries = max_tries+1;
384
385	unsigned int gen_before = get1394Service().getGeneration();
386
387	while(--ntries) {
388	if (rebootOnSamplerateChange) {
389	debugOutput( DEBUG_LEVEL_VERBOSE, "Setting samplerate with reboot\n");
390	if(!setSamplingFrequencyDo( value )) {
391	debugWarning("setSamplingFrequencyDo failed\n");
392	}
393
394	debugOutput( DEBUG_LEVEL_VERBOSE, "Waiting for device to finish rebooting...\n");
395
396	// the device needs quite some time to reboot
397	SleepRelativeUsec(2 * 1000 * 1000);
398
399	int timeout = 5; // multiples of 1s
400	// wait for a busreset to occur
401	while ((gen_before == get1394Service().getGeneration())
402	&& --timeout)
403	{
404	// wait for a while
405	SleepRelativeUsec(1000 * 1000);
406	}
407	if (!timeout) {
408	debugOutput(DEBUG_LEVEL_VERBOSE, "Device did not reset itself, forcing reboot...\n");
409	rebootDevice();
410
411	// the device needs quite some time to reboot
412	SleepRelativeUsec(2 * 1000 * 1000);
413
414	// wait for the device to finish the reboot
415	timeout = 10; // multiples of 1s
416	while ((gen_before == get1394Service().getGeneration())
417	&& --timeout)
418	{
419	// wait for a while
420	SleepRelativeUsec(1000 * 1000);
421	}
422	if (!timeout) {
423	debugError( "Device did not reset itself after forced reboot...\n");
424	return false;
425	}
426	}
427
428	// so we know the device is rebooting
429	// now wait until it stops generating busresets
430	timeout = 10;
431	unsigned int gen_current;
432	do {
433	gen_current=get1394Service().getGeneration();
434	debugOutput(DEBUG_LEVEL_VERBOSE, "Waiting... (gen: %u)\n", gen_current);
435
436	// wait for a while
437	SleepRelativeUsec(4 * 1000 * 1000);
438	} while (gen_current != get1394Service().getGeneration()
439	&& --timeout);
440
441	if (!timeout) {
442	debugError( "Device did not recover from reboot...\n");
443	return false;
444	}
445
446	debugOutput(DEBUG_LEVEL_VERBOSE, "Device available (gen: %u => %u)...\n",
447	gen_before, get1394Service().getGeneration());
448
449	// wait some more
450	SleepRelativeUsec(1 * 1000 * 1000);
451
452	// we have to rediscover the device
453	if (discover()) break;
454	} else {
455	debugOutput( DEBUG_LEVEL_VERBOSE, "Setting samplerate without reboot\n");
456	if(!setSamplingFrequencyDoNoReboot( value )) {
457	debugWarning("setSamplingFrequencyDoNoReboot failed\n");
458	}
459	}
460
461	int verify=getSamplingFrequency();
462	debugOutput( DEBUG_LEVEL_VERBOSE,
463	"setSampleRate (try %d): requested samplerate %d, device now has %d\n",
464	max_tries-ntries, s, verify );
465
466	if (s == verify) {
467	break;
468	}
469	debugOutput( DEBUG_LEVEL_VERBOSE, "setSampleRate (try %d) failed. Try again...\n" );
470	}
471
472	if (ntries==0) {
473	debugError("Setting samplerate failed...\n");
474	return false;
475	}
476
477	return true;
478	}
479	// not executable
480	return false;
481
482	}
483
484	void
485	SaffireProDevice::rebootDevice() {
486	debugOutput( DEBUG_LEVEL_VERBOSE, "rebooting device...\n" );
487	if ( !setSpecificValue(FR_SAFFIREPRO_CMD_ID_REBOOT,
488	FR_SAFFIREPRO_CMD_REBOOT_CODE ) ) {
489	debugError( "setSpecificValue failed\n" );
490	}
491	}
492
493	void
494	SaffireProDevice::exitStandalone() {
495	debugOutput( DEBUG_LEVEL_VERBOSE, "exit standalone mode...\n" );
496	if ( !setSpecificValue(FR_SAFFIREPRO_CMD_ID_EXIT_STANDALONE,
497	FR_SAFFIREPRO_CMD_EXIT_STANDALONE_CODE ) ) {
498	debugError( "setSpecificValue failed\n" );
499	}
500	}
501
502	void
503	SaffireProDevice::flashLed() {
504	int ledFlashDuration=2;
505	if(!getOption("ledFlashDuration", ledFlashDuration)) {
506	debugWarning("Could not retrieve ledFlashDuration parameter, defaulting to 2sec\n");
507	}
508	int ledFlashFrequency=10;
509	if(!getOption("ledFlashFrequency", ledFlashFrequency)) {
510	debugWarning("Could not retrieve ledFlashFrequency parameter, defaulting to 10Hz\n");
511	}
512
513	uint32_t reg=0;
514	debugOutput( DEBUG_LEVEL_VERBOSE, "flashing led ...\n" );
515
516	reg = FR_SAFFIREPRO_CMD_SET_FLASH_SECS(reg, ledFlashDuration);
517	reg = FR_SAFFIREPRO_CMD_SET_FLASH_FREQ(reg, ledFlashFrequency);
518
519	if ( !setSpecificValue(FR_SAFFIREPRO_CMD_ID_FLASH_LED,
520	reg ) ) {
521	debugError( "setSpecificValue failed\n" );
522	}
523	}
524
525	bool
526	SaffireProDevice::isAudioOn() {
527	uint32_t ready;
528	if ( !getSpecificValue(FR_SAFFIREPRO_CMD_ID_AUDIO_ON, &ready ) ) {
529	debugError( "getSpecificValue failed\n" );
530	return false;
531	}
532
533	debugOutput( DEBUG_LEVEL_VERBOSE,
534	"isAudioOn: %d\n", ready!=0 );
535	return ready != 0;
536	}
537
538	bool
539	SaffireProDevice::isExtClockLocked() {
540	uint32_t ready;
541	if ( !getSpecificValue(FR_SAFFIREPRO_CMD_ID_EXT_CLOCK_LOCK, &ready ) ) {
542	debugError( "getSpecificValue failed\n" );
543	return false;
544	}
545
546	debugOutput( DEBUG_LEVEL_VERBOSE,
547	"isExtClockLocked: %d\n", ready!=0 );
548	return ready != 0;
549	}
550
551	uint32_t
552	SaffireProDevice::getCount32() {
553	uint32_t v;
554	if ( !getSpecificValue(FR_SAFFIREPRO_CMD_ID_PLAYBACK_COUNT, &v ) ) {
555	debugError( "getSpecificValue failed\n" );
556	return false;
557	}
558
559	debugOutput( DEBUG_LEVEL_VERBOSE,
560	"getCount32: %08lX\n", v );
561	return v;
562	}
563
564	void
565	SaffireProDevice::useHighVoltageRail(bool useIt) {
566	uint32_t reg=useIt;
567	debugOutput( DEBUG_LEVEL_VERBOSE, "%s high voltage rail ...\n",
568	(useIt?"Using":"Not using") );
569
570	if ( !setSpecificValue(FR_SAFFIREPRO_CMD_ID_USE_HIGHVOLTAGE_RAIL,
571	reg ) ) {
572	debugError( "setSpecificValue failed\n" );
573	}
574	}
575
576	bool
577	SaffireProDevice::usingHighVoltageRail() {
578	uint32_t retval;
579	if ( !getSpecificValue(FR_SAFFIREPRO_CMD_ID_USING_HIGHVOLTAGE_RAIL, &retval ) ) {
580	debugError( "getSpecificValue failed\n" );
581	return false;
582	}
583
584	debugOutput( DEBUG_LEVEL_VERBOSE,
585	"usingHighVoltageRail: %d\n", retval!=0 );
586	return retval != 0;
587	}
588
589	void
590	SaffireProDevice::setPllLockRange(unsigned int i) {
591	uint32_t reg=i;
592	debugOutput( DEBUG_LEVEL_VERBOSE, "set PLL lock range: %d ...\n", i );
593
594	if ( !setSpecificValue(FR_SAFFIREPRO_CMD_ID_PLL_LOCK_RANGE,
595	reg ) ) {
596	debugError( "setSpecificValue failed\n" );
597	}
598	}
599
600	unsigned int
601	SaffireProDevice::getPllLockRange() {
602	uint32_t retval;
603	if ( !getSpecificValue(FR_SAFFIREPRO_CMD_ID_PLL_LOCK_RANGE, &retval ) ) {
604	debugError( "getSpecificValue failed\n" );
605	return false;
606	}
607
608	debugOutput( DEBUG_LEVEL_VERBOSE,
609	"PLL lock range: %d\n", retval );
610	return retval;
611	}
612
613	// swiss army knife control element
614	SaffireProMultiControl::SaffireProMultiControl(SaffireProDevice& parent, enum eMultiControlType t)
615	: Control::Discrete()
616	, m_Parent(parent)
617	, m_type ( t )
618	{}
619	SaffireProMultiControl::SaffireProMultiControl(SaffireProDevice& parent, enum eMultiControlType t,
620	std::string name, std::string label, std::string descr)
621	: Control::Discrete()
622	, m_Parent(parent)
623	, m_type ( t )
624	{
625	setName(name);
626	setLabel(label);
627	setDescription(descr);
628	}
629
630	bool
631	SaffireProMultiControl::setValue(int v)
632	{
633	switch (m_type) {
634	case eTCT_Reboot: m_Parent.rebootDevice(); return true;
635	case eTCT_FlashLed: m_Parent.flashLed(); return true;
636	case eTCT_UseHighVoltageRail: m_Parent.useHighVoltageRail(v); return true;
637	case eTCT_ExitStandalone: m_Parent.exitStandalone(); return true;
638	case eTCT_PllLockRange: m_Parent.setPllLockRange(v); return true;
639	}
640	return false;
641	}
642
643	int
644	SaffireProMultiControl::getValue()
645	{
646	switch (m_type) {
647	case eTCT_Reboot: return 0;
648	case eTCT_FlashLed: return 0;
649	case eTCT_UseHighVoltageRail: return m_Parent.usingHighVoltageRail();
650	case eTCT_ExitStandalone: return 0;
651	case eTCT_PllLockRange: return m_Parent.getPllLockRange();
652	}
653	return -1;
654	}
655
656
657	// Saffire pro matrix mixer element
658
659	SaffireProMatrixMixer::SaffireProMatrixMixer(SaffireProDevice& p,
660	enum eMatrixMixerType type)
661	: FocusriteMatrixMixer(p, "MatrixMixer")
662	, m_type(type)
663	{
664	init();
665	}
666
667	SaffireProMatrixMixer::SaffireProMatrixMixer(SaffireProDevice& p,
668	enum eMatrixMixerType type, std::string n)
669	: FocusriteMatrixMixer(p, n)
670	, m_type(type)
671	{
672	init();
673	}
674
675	void SaffireProMatrixMixer::init()
676	{
677	if (m_type==eMMT_OutputMix) {
678	addSignalInfo(m_RowInfo, "PC1", "PC 1", "PC Channel 1");
679	addSignalInfo(m_RowInfo, "PC2", "PC 2", "PC Channel 2");
680	addSignalInfo(m_RowInfo, "PC3", "PC 3", "PC Channel 3");
681	addSignalInfo(m_RowInfo, "PC4", "PC 4", "PC Channel 4");
682	addSignalInfo(m_RowInfo, "PC5", "PC 5", "PC Channel 5");
683	addSignalInfo(m_RowInfo, "PC6", "PC 6", "PC Channel 6");
684	addSignalInfo(m_RowInfo, "PC7", "PC 7", "PC Channel 7");
685	addSignalInfo(m_RowInfo, "PC8", "PC 8", "PC Channel 8");
686	addSignalInfo(m_RowInfo, "PC9", "PC 9", "PC Channel 9");
687	addSignalInfo(m_RowInfo, "PC10", "PC 10", "PC Channel 10");
688	addSignalInfo(m_RowInfo, "IMIXL", "IMix L", "Input Mix Left");
689	addSignalInfo(m_RowInfo, "IMIXR", "IMix R", "Input Mix Right");
690
691	addSignalInfo(m_ColInfo, "OUT1", "OUT 1", "Output Channel 1");
692	addSignalInfo(m_ColInfo, "OUT2", "OUT 2", "Output Channel 2");
693	addSignalInfo(m_ColInfo, "OUT3", "OUT 3", "Output Channel 3");
694	addSignalInfo(m_ColInfo, "OUT4", "OUT 4", "Output Channel 4");
695	addSignalInfo(m_ColInfo, "OUT5", "OUT 5", "Output Channel 5");
696	addSignalInfo(m_ColInfo, "OUT6", "OUT 6", "Output Channel 6");
697	addSignalInfo(m_ColInfo, "OUT7", "OUT 7", "Output Channel 7");
698	addSignalInfo(m_ColInfo, "OUT8", "OUT 8", "Output Channel 8");
699	addSignalInfo(m_ColInfo, "OUT9", "OUT 9", "Output Channel 9");
700	addSignalInfo(m_ColInfo, "OUT10", "OUT 10", "Output Channel 10");
701
702	// init the cell matrix
703	#define FOCUSRITE_SAFFIRE_PRO_OUTMIX_NB_COLS 10
704	#define FOCUSRITE_SAFFIRE_PRO_OUTMIX_NB_ROWS 12
705
706	std::vector<struct sCellInfo> tmp_cols( FOCUSRITE_SAFFIRE_PRO_OUTMIX_NB_COLS );
707	std::vector< std::vector<struct sCellInfo> > tmp_all(FOCUSRITE_SAFFIRE_PRO_OUTMIX_NB_ROWS, tmp_cols);
708	m_CellInfo = tmp_all;
709
710	struct sCellInfo c;
711	c.row=-1;
712	c.col=-1;
713	c.valid=false;
714	c.address=0;
715
716	for (int i=0;i<FOCUSRITE_SAFFIRE_PRO_OUTMIX_NB_ROWS;i++) {
717	for (int j=0;j<FOCUSRITE_SAFFIRE_PRO_OUTMIX_NB_COLS;j++) {
718	m_CellInfo[i][j]=c;
719	}
720	}
721
722	// now set the cells that are valid
723	setCellInfo(0,0,FR_SAFFIREPRO_CMD_ID_PC1_TO_OUT1, true);
724	setCellInfo(1,1,FR_SAFFIREPRO_CMD_ID_PC2_TO_OUT2, true);
725	setCellInfo(10,0,FR_SAFFIREPRO_CMD_ID_MIX1_TO_OUT1, true);
726	setCellInfo(11,1,FR_SAFFIREPRO_CMD_ID_MIX2_TO_OUT2, true);
727	setCellInfo(0,2,FR_SAFFIREPRO_CMD_ID_PC1_TO_OUT3, true);
728	setCellInfo(1,3,FR_SAFFIREPRO_CMD_ID_PC2_TO_OUT4, true);
729	setCellInfo(2,2,FR_SAFFIREPRO_CMD_ID_PC3_TO_OUT3, true);
730	setCellInfo(3,3,FR_SAFFIREPRO_CMD_ID_PC4_TO_OUT4, true);
731	setCellInfo(10,2,FR_SAFFIREPRO_CMD_ID_MIX1_TO_OUT3, true);
732	setCellInfo(11,3,FR_SAFFIREPRO_CMD_ID_MIX2_TO_OUT4, true);
733	setCellInfo(0,4,FR_SAFFIREPRO_CMD_ID_PC1_TO_OUT5, true);
734	setCellInfo(1,5,FR_SAFFIREPRO_CMD_ID_PC2_TO_OUT6, true);
735	setCellInfo(4,4,FR_SAFFIREPRO_CMD_ID_PC5_TO_OUT5, true);
736	setCellInfo(5,5,FR_SAFFIREPRO_CMD_ID_PC6_TO_OUT6, true);
737	setCellInfo(10,4,FR_SAFFIREPRO_CMD_ID_MIX1_TO_OUT5, true);
738	setCellInfo(11,5,FR_SAFFIREPRO_CMD_ID_MIX2_TO_OUT6, true);
739	setCellInfo(0,6,FR_SAFFIREPRO_CMD_ID_PC1_TO_OUT7, true);
740	setCellInfo(1,7,FR_SAFFIREPRO_CMD_ID_PC2_TO_OUT8, true);
741	setCellInfo(6,6,FR_SAFFIREPRO_CMD_ID_PC7_TO_OUT7, true);
742	setCellInfo(7,7,FR_SAFFIREPRO_CMD_ID_PC8_TO_OUT8, true);
743	setCellInfo(10,6,FR_SAFFIREPRO_CMD_ID_MIX1_TO_OUT7, true);
744	setCellInfo(11,7,FR_SAFFIREPRO_CMD_ID_MIX2_TO_OUT8, true);
745	setCellInfo(0,8,FR_SAFFIREPRO_CMD_ID_PC1_TO_OUT9, true);
746	setCellInfo(1,9,FR_SAFFIREPRO_CMD_ID_PC2_TO_OUT10, true);
747	setCellInfo(8,8,FR_SAFFIREPRO_CMD_ID_PC9_TO_OUT9, true);
748	setCellInfo(9,9,FR_SAFFIREPRO_CMD_ID_PC10_TO_OUT10, true);
749	setCellInfo(10,8,FR_SAFFIREPRO_CMD_ID_MIX1_TO_OUT9, true);
750	setCellInfo(11,9,FR_SAFFIREPRO_CMD_ID_MIX2_TO_OUT10, true);
751
752	} else if (m_type==eMMT_InputMix) {
753	addSignalInfo(m_RowInfo, "AN1", "Analog 1", "Analog Input 1");
754	addSignalInfo(m_RowInfo, "AN2", "Analog 2", "Analog Input 2");
755	addSignalInfo(m_RowInfo, "AN3", "Analog 3", "Analog Input 3");
756	addSignalInfo(m_RowInfo, "AN4", "Analog 4", "Analog Input 4");
757	addSignalInfo(m_RowInfo, "AN5", "Analog 5", "Analog Input 5");
758	addSignalInfo(m_RowInfo, "AN6", "Analog 6", "Analog Input 6");
759	addSignalInfo(m_RowInfo, "AN7", "Analog 7", "Analog Input 7");
760	addSignalInfo(m_RowInfo, "AN8", "Analog 8", "Analog Input 8");
761	addSignalInfo(m_RowInfo, "SPDIFL", "SPDIF L", "SPDIF Left Input");
762	addSignalInfo(m_RowInfo, "SPDIFR", "SPDIF R", "SPDIF Right Input");
763
764	addSignalInfo(m_RowInfo, "ADAT11", "ADAT1 1", "ADAT1 Channel 1");
765	addSignalInfo(m_RowInfo, "ADAT12", "ADAT1 2", "ADAT1 Channel 2");
766	addSignalInfo(m_RowInfo, "ADAT13", "ADAT1 3", "ADAT1 Channel 3");
767	addSignalInfo(m_RowInfo, "ADAT14", "ADAT1 4", "ADAT1 Channel 4");
768	addSignalInfo(m_RowInfo, "ADAT15", "ADAT1 5", "ADAT1 Channel 5");
769	addSignalInfo(m_RowInfo, "ADAT16", "ADAT1 6", "ADAT1 Channel 6");
770	addSignalInfo(m_RowInfo, "ADAT17", "ADAT1 7", "ADAT1 Channel 7");
771	addSignalInfo(m_RowInfo, "ADAT18", "ADAT1 8", "ADAT1 Channel 8");
772
773	addSignalInfo(m_RowInfo, "ADAT21", "ADAT2 1", "ADAT2 Channel 1");
774	addSignalInfo(m_RowInfo, "ADAT22", "ADAT2 2", "ADAT2 Channel 2");
775	addSignalInfo(m_RowInfo, "ADAT23", "ADAT2 3", "ADAT2 Channel 3");
776	addSignalInfo(m_RowInfo, "ADAT24", "ADAT2 4", "ADAT2 Channel 4");
777	addSignalInfo(m_RowInfo, "ADAT25", "ADAT2 5", "ADAT2 Channel 5");
778	addSignalInfo(m_RowInfo, "ADAT26", "ADAT2 6", "ADAT2 Channel 6");
779	addSignalInfo(m_RowInfo, "ADAT27", "ADAT2 7", "ADAT2 Channel 7");
780	addSignalInfo(m_RowInfo, "ADAT28", "ADAT2 8", "ADAT2 Channel 8");
781
782	addSignalInfo(m_ColInfo, "IMIXL", "IMix L", "Input Mix Left");
783	addSignalInfo(m_ColInfo, "IMIXR", "IMix R", "Input Mix Right");
784
785	// init the cell matrix
786	#define FOCUSRITE_SAFFIRE_PRO_INMIX_NB_COLS 2
787	#define FOCUSRITE_SAFFIRE_PRO_INMIX_NB_ROWS 26
788
789	std::vector<struct sCellInfo> tmp_cols( FOCUSRITE_SAFFIRE_PRO_INMIX_NB_COLS );
790	std::vector< std::vector<struct sCellInfo> > tmp_all(FOCUSRITE_SAFFIRE_PRO_INMIX_NB_ROWS,tmp_cols);
791	m_CellInfo = tmp_all;
792
793	struct sCellInfo c;
794	c.row=-1;
795	c.col=-1;
796	c.valid=false;
797	c.address=0;
798
799	for (int i=0;i<FOCUSRITE_SAFFIRE_PRO_INMIX_NB_ROWS;i++) {
800	for (int j=0;j<FOCUSRITE_SAFFIRE_PRO_INMIX_NB_COLS;j++) {
801	m_CellInfo[i][j]=c;
802	}
803	}
804
805	// now set the cells that are valid
806	setCellInfo(0,0,FR_SAFFIREPRO_CMD_ID_AN1_TO_IMIXL, true);
807	setCellInfo(0,1,FR_SAFFIREPRO_CMD_ID_AN1_TO_IMIXR, true);
808	setCellInfo(1,0,FR_SAFFIREPRO_CMD_ID_AN2_TO_IMIXL, true);
809	setCellInfo(1,1,FR_SAFFIREPRO_CMD_ID_AN2_TO_IMIXR, true);
810	setCellInfo(2,0,FR_SAFFIREPRO_CMD_ID_AN3_TO_IMIXL, true);
811	setCellInfo(2,1,FR_SAFFIREPRO_CMD_ID_AN3_TO_IMIXR, true);
812	setCellInfo(3,0,FR_SAFFIREPRO_CMD_ID_AN4_TO_IMIXL, true);
813	setCellInfo(3,1,FR_SAFFIREPRO_CMD_ID_AN4_TO_IMIXR, true);
814	setCellInfo(4,0,FR_SAFFIREPRO_CMD_ID_AN5_TO_IMIXL, true);
815	setCellInfo(4,1,FR_SAFFIREPRO_CMD_ID_AN5_TO_IMIXR, true);
816	setCellInfo(5,0,FR_SAFFIREPRO_CMD_ID_AN6_TO_IMIXL, true);
817	setCellInfo(5,1,FR_SAFFIREPRO_CMD_ID_AN6_TO_IMIXR, true);
818	setCellInfo(6,0,FR_SAFFIREPRO_CMD_ID_AN7_TO_IMIXL, true);
819	setCellInfo(6,1,FR_SAFFIREPRO_CMD_ID_AN7_TO_IMIXR, true);
820	setCellInfo(7,0,FR_SAFFIREPRO_CMD_ID_AN8_TO_IMIXL, true);
821	setCellInfo(7,1,FR_SAFFIREPRO_CMD_ID_AN8_TO_IMIXR, true);
822	setCellInfo(8,0,FR_SAFFIREPRO_CMD_ID_SPDIFL_TO_IMIXL, true);
823	setCellInfo(8,1,FR_SAFFIREPRO_CMD_ID_SPDIFL_TO_IMIXR, true);
824	setCellInfo(9,0,FR_SAFFIREPRO_CMD_ID_SPDIFR_TO_IMIXL, true);
825	setCellInfo(9,1,FR_SAFFIREPRO_CMD_ID_SPDIFR_TO_IMIXR, true);
826
827	setCellInfo(10,0,FR_SAFFIREPRO_CMD_ID_ADAT11_TO_IMIXL, true);
828	setCellInfo(10,1,FR_SAFFIREPRO_CMD_ID_ADAT11_TO_IMIXR, true);
829	setCellInfo(11,0,FR_SAFFIREPRO_CMD_ID_ADAT12_TO_IMIXL, true);
830	setCellInfo(11,1,FR_SAFFIREPRO_CMD_ID_ADAT12_TO_IMIXR, true);
831	setCellInfo(12,0,FR_SAFFIREPRO_CMD_ID_ADAT13_TO_IMIXL, true);
832	setCellInfo(12,1,FR_SAFFIREPRO_CMD_ID_ADAT13_TO_IMIXR, true);
833	setCellInfo(13,0,FR_SAFFIREPRO_CMD_ID_ADAT14_TO_IMIXL, true);
834	setCellInfo(13,1,FR_SAFFIREPRO_CMD_ID_ADAT14_TO_IMIXR, true);
835	setCellInfo(14,0,FR_SAFFIREPRO_CMD_ID_ADAT15_TO_IMIXL, true);
836	setCellInfo(14,1,FR_SAFFIREPRO_CMD_ID_ADAT15_TO_IMIXR, true);
837	setCellInfo(15,0,FR_SAFFIREPRO_CMD_ID_ADAT16_TO_IMIXL, true);
838	setCellInfo(15,1,FR_SAFFIREPRO_CMD_ID_ADAT16_TO_IMIXR, true);
839	setCellInfo(16,0,FR_SAFFIREPRO_CMD_ID_ADAT17_TO_IMIXL, true);
840	setCellInfo(16,1,FR_SAFFIREPRO_CMD_ID_ADAT17_TO_IMIXR, true);
841	setCellInfo(17,0,FR_SAFFIREPRO_CMD_ID_ADAT18_TO_IMIXL, true);
842	setCellInfo(17,1,FR_SAFFIREPRO_CMD_ID_ADAT18_TO_IMIXR, true);
843
844	setCellInfo(18,0,FR_SAFFIREPRO_CMD_ID_ADAT21_TO_IMIXL, true);
845	setCellInfo(18,1,FR_SAFFIREPRO_CMD_ID_ADAT21_TO_IMIXR, true);
846	setCellInfo(19,0,FR_SAFFIREPRO_CMD_ID_ADAT22_TO_IMIXL, true);
847	setCellInfo(19,1,FR_SAFFIREPRO_CMD_ID_ADAT22_TO_IMIXR, true);
848	setCellInfo(20,0,FR_SAFFIREPRO_CMD_ID_ADAT23_TO_IMIXL, true);
849	setCellInfo(20,1,FR_SAFFIREPRO_CMD_ID_ADAT23_TO_IMIXR, true);
850	setCellInfo(21,0,FR_SAFFIREPRO_CMD_ID_ADAT24_TO_IMIXL, true);
851	setCellInfo(21,1,FR_SAFFIREPRO_CMD_ID_ADAT24_TO_IMIXR, true);
852	setCellInfo(22,0,FR_SAFFIREPRO_CMD_ID_ADAT25_TO_IMIXL, true);
853	setCellInfo(22,1,FR_SAFFIREPRO_CMD_ID_ADAT25_TO_IMIXR, true);
854	setCellInfo(23,0,FR_SAFFIREPRO_CMD_ID_ADAT26_TO_IMIXL, true);
855	setCellInfo(23,1,FR_SAFFIREPRO_CMD_ID_ADAT26_TO_IMIXR, true);
856	setCellInfo(24,0,FR_SAFFIREPRO_CMD_ID_ADAT27_TO_IMIXL, true);
857	setCellInfo(24,1,FR_SAFFIREPRO_CMD_ID_ADAT27_TO_IMIXR, true);
858	setCellInfo(25,0,FR_SAFFIREPRO_CMD_ID_ADAT28_TO_IMIXL, true);
859	setCellInfo(25,1,FR_SAFFIREPRO_CMD_ID_ADAT28_TO_IMIXR, true);
860
861	} else {
862	debugError("Invalid mixer type\n");
863	}
864	}
865
866	void SaffireProMatrixMixer::show()
867	{
868	debugOutput(DEBUG_LEVEL_NORMAL, "Saffire Pro Matrix mixer type %d\n");
869	}
870
871	} // Focusrite
872	} // BeBoB

Note: See TracBrowser for help on using the browser.

root/trunk/libffado/src/bebob/focusrite/focusrite_saffirepro.cpp

Download in other formats: