focusrite_saffirepro.cpp

Revision 684, 32.2 kB (checked in by ppalmers, 15 years ago)
- extend the saffire pro mixer

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

Note: See TracBrowser for help on using the browser.

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

Download in other formats: