dice_avdevice.h

Revision 1651, 20.1 kB (checked in by arnonym, 14 years ago)

Lets see if this works out: Work for ppalmers.

A new way to get the peakvalues. Getting each value individual is really cpu-heavy. Getting them all toghether should be better.

(My first real code commit to the internals:)

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	#ifndef DICEDEVICE_H
25	#define DICEDEVICE_H
26
27	#include "ffadodevice.h"
28
29	#include "debugmodule/debugmodule.h"
30	#include "libavc/avc_definitions.h"
31
32	#include "libstreaming/amdtp/AmdtpReceiveStreamProcessor.h"
33	#include "libstreaming/amdtp/AmdtpTransmitStreamProcessor.h"
34	#include "libstreaming/amdtp/AmdtpPort.h"
35
36	#include "libieee1394/ieee1394service.h"
37
38	#include "libcontrol/Element.h"
39	#include "libcontrol/MatrixMixer.h"
40	#include "libcontrol/CrossbarRouter.h"
41
42	#include "dice_eap.h"
43
44	#include <string>
45	#include <vector>
46
47	class ConfigRom;
48	class Ieee1394Service;
49
50	namespace Util {
51	class Configuration;
52	}
53
54	namespace Dice {
55
56	class Notifier;
57
58	class Device : public FFADODevice {
59	// private:
60	typedef std::vector< std::string > diceNameVector;
61	typedef std::vector< std::string >::iterator diceNameVectorIterator;
62
63	public:
64	class Notifier;
65	class EAP;
66
67	/**
68	* this class represents the EAP interface
69	* available on some devices
70	*/
71	class EAP : public Control::Container
72	{
73	public:
74	enum eWaitReturn {
75	eWR_Error,
76	eWR_Timeout,
77	eWR_Busy,
78	eWR_Done,
79	};
80	enum eRegBase {
81	eRT_Base,
82	eRT_Capability,
83	eRT_Command,
84	eRT_Mixer,
85	eRT_Peak,
86	eRT_NewRouting,
87	eRT_NewStreamCfg,
88	eRT_CurrentCfg,
89	eRT_Standalone,
90	eRT_Application,
91	eRT_None,
92	};
93	enum eRouteSource {
94	eRS_AES = 0,
95	eRS_ADAT = 1,
96	eRS_Mixer = 2,
97	eRS_InS0 = 4,
98	eRS_InS1 = 5,
99	eRS_ARM = 10,
100	eRS_ARX0 = 11,
101	eRS_ARX1 = 12,
102	eRS_Muted = 15,
103	eRS_Invalid = 16,
104	};
105	enum eRouteDestination {
106	eRD_AES = 0,
107	eRD_ADAT = 1,
108	eRD_Mixer0 = 2,
109	eRD_Mixer1 = 3,
110	eRD_InS0 = 4,
111	eRD_InS1 = 5,
112	eRD_ARM = 10,
113	eRD_ATX0 = 11,
114	eRD_ATX1 = 12,
115	eRD_Muted = 15,
116	eRD_Invalid = 16,
117	};
118
119	public:
120
121	// ----------
122	class RouterConfig {
123	public:
124	struct Route
125	{
126	enum eRouteSource src;
127	int srcChannel;
128	enum eRouteDestination dst;
129	int dstChannel;
130	int peak;
131	};
132	typedef std::vector<RouterConfig::Route> RouteVector;
133	typedef std::vector<RouterConfig::Route>::iterator RouteVectorIterator;
134	RouterConfig(EAP &);
135	RouterConfig(EAP &, enum eRegBase, unsigned int offset);
136	virtual ~RouterConfig();
137
138	virtual bool read() {return read(m_base, m_offset);};
139	virtual bool write() {return write(m_base, m_offset);};
140	virtual bool read(enum eRegBase b, unsigned offset);
141	virtual bool write(enum eRegBase b, unsigned offset);
142	virtual void show();
143
144
145	bool insertRoute(struct Route r)
146	{return insertRoute(r, m_routes.size());};
147	bool insertRoute(struct Route r, unsigned int index);
148	bool replaceRoute(unsigned int old_index, struct Route new_route);
149	bool replaceRoute(struct Route old_route, struct Route new_route);
150	bool removeRoute(struct Route r);
151	bool removeRoute(unsigned int index);
152	int getRouteIndex(struct Route r);
153	struct Route getRoute(unsigned int index);
154
155	unsigned int getNbRoutes() {return m_routes.size();};
156
157	struct Route getRouteForDestination(enum eRouteDestination dst, int channel);
158	RouteVector getRoutesForSource(enum eRouteSource src, int channel);
159
160	struct Route decodeRoute(uint32_t val);
161	uint32_t encodeRoute(struct Route r);
162	public:
163	static enum eRouteDestination intToRouteDestination(int);
164	static enum eRouteSource intToRouteSource(int);
165	protected:
166	EAP &m_eap;
167	enum eRegBase m_base;
168	unsigned int m_offset;
169	RouteVector m_routes;
170	protected:
171	DECLARE_DEBUG_MODULE_REFERENCE;
172	};
173
174	// ----------
175	// the peak space is a special version of a router config
176	class PeakSpace : public RouterConfig {
177	public:
178	PeakSpace(EAP &p) : RouterConfig(p, eRT_Peak, 0) {};
179	virtual ~PeakSpace() {};
180
181	virtual bool read() {return read(m_base, m_offset);};
182	virtual bool write() {return write(m_base, m_offset);};
183	virtual bool read(enum eRegBase b, unsigned offset);
184	virtual bool write(enum eRegBase b, unsigned offset);
185	virtual void show();
186	};
187
188	// ----------
189	class StreamConfig {
190	public:
191	struct ConfigBlock { // FIXME: somewhere in the DICE avdevice this is present too
192	uint32_t nb_audio;
193	uint32_t nb_midi;
194	uint32_t names[DICE_EAP_CHANNEL_CONFIG_NAMESTR_LEN_QUADS];
195	uint32_t ac3_map;
196	};
197	void showConfigBlock(struct ConfigBlock &);
198	diceNameVector getNamesForBlock(struct ConfigBlock &b);
199	public:
200	StreamConfig(EAP &, enum eRegBase, unsigned int offset);
201	~StreamConfig();
202
203	bool read() {return read(m_base, m_offset);};
204	bool write() {return write(m_base, m_offset);};
205	bool read(enum eRegBase b, unsigned offset);
206	bool write(enum eRegBase b, unsigned offset);
207
208	void show();
209
210	private:
211	EAP &m_eap;
212	enum eRegBase m_base;
213	unsigned int m_offset;
214
215	uint32_t m_nb_tx;
216	uint32_t m_nb_rx;
217
218	struct ConfigBlock *m_tx_configs;
219	struct ConfigBlock *m_rx_configs;
220
221	DECLARE_DEBUG_MODULE_REFERENCE;
222	};
223
224	public: // mixer control subclass
225	class Mixer : public Control::MatrixMixer {
226	public:
227	Mixer(EAP &);
228	~Mixer();
229
230	bool init();
231	void show();
232
233	void updateNameCache();
234	/**
235	* load the coefficients from the device into the local cache
236	* @return
237	*/
238	bool loadCoefficients();
239	/**
240	* Stores the coefficients from the cache to the device
241	* @return
242	*/
243	bool storeCoefficients();
244
245	virtual std::string getRowName( const int );
246	virtual std::string getColName( const int );
247	virtual int canWrite( const int, const int );
248	virtual double setValue( const int, const int, const double );
249	virtual double getValue( const int, const int );
250	virtual int getRowCount( );
251	virtual int getColCount( );
252
253	// full map updates are unsupported
254	virtual bool getCoefficientMap(int &);
255	virtual bool storeCoefficientMap(int &);
256
257	private:
258	EAP & m_eap;
259	fb_quadlet_t *m_coeff;
260
261	std::map<int, RouterConfig::Route> m_input_route_map;
262	std::map<int, RouterConfig::RouteVector> m_output_route_map;
263
264	DECLARE_DEBUG_MODULE_REFERENCE;
265	};
266
267	// ----------
268	class Router : public Control::CrossbarRouter {
269	private:
270	struct Source {
271	std::string name;
272	enum eRouteSource src;
273	int srcChannel;
274	};
275	typedef std::vector<Source> SourceVector;
276	typedef std::vector<Source>::iterator SourceVectorIterator;
277
278	struct Destination {
279	std::string name;
280	enum eRouteDestination dst;
281	int dstChannel;
282	};
283	typedef std::vector<Destination> DestinationVector;
284	typedef std::vector<Destination>::iterator DestinationVectorIterator;
285
286	public:
287	Router(EAP &);
288	~Router();
289
290	void show();
291
292	// to be subclassed by the implementing
293	// devices
294	virtual void setupSources();
295	virtual void setupDestinations();
296
297	void setupDestinationsAddDestination(const char *name, enum eRouteDestination dstid,
298	unsigned int base, unsigned int cnt);
299	void setupSourcesAddSource(const char *name, enum eRouteSource srcid,
300	unsigned int base, unsigned int cnt);
301
302	int getDestinationIndex(enum eRouteDestination dstid, int channel);
303	int getSourceIndex(enum eRouteSource srcid, int channel);
304
305	// per-coefficient access
306	virtual std::string getSourceName(const int);
307	virtual std::string getDestinationName(const int);
308	virtual int getSourceIndex(std::string);
309	virtual int getDestinationIndex(std::string);
310	virtual NameVector getSourceNames();
311	virtual NameVector getDestinationNames();
312
313	virtual IntVector getDestinationsForSource(const int);
314	virtual int getSourceForDestination(const int);
315
316	virtual bool canConnect( const int source, const int dest);
317	virtual bool setConnectionState( const int source, const int dest, const bool enable);
318	virtual bool getConnectionState( const int source, const int dest );
319
320	virtual bool canConnect(std::string, std::string);
321	virtual bool setConnectionState(std::string, std::string, const bool enable);
322	virtual bool getConnectionState(std::string, std::string);
323
324	virtual bool clearAllConnections();
325
326	virtual int getNbSources();
327	virtual int getNbDestinations();
328
329	// functions to access the entire routing map at once
330	// idea is that the row/col nodes that are 1 get a routing entry
331	virtual bool getConnectionMap(int *);
332	virtual bool setConnectionMap(int *);
333
334	// peak metering support
335	virtual bool hasPeakMetering();
336	virtual bool getPeakValues(double &) {return false;};
337	virtual double getPeakValue(const int source, const int dest);
338	virtual Control::CrossbarRouter::PeakValues getPeakValues();
339
340	private:
341	EAP &m_eap;
342	// these contain the sources and destinations available for this
343	// router
344	SourceVector m_sources;
345	DestinationVector m_destinations;
346
347	PeakSpace &m_peak;
348
349	DECLARE_DEBUG_MODULE_REFERENCE;
350	};
351
352	public:
353	EAP(Device &);
354	virtual ~EAP();
355
356	static bool supportsEAP(Device &);
357	bool init();
358
359	void show();
360	enum eWaitReturn operationBusy();
361	enum eWaitReturn waitForOperationEnd(int max_wait_time_ms = 100);
362
363	bool updateConfigurationCache();
364	RouterConfig * getActiveRouterConfig();
365	StreamConfig * getActiveStreamConfig();
366
367	bool updateRouterConfig(RouterConfig&, bool low, bool mid, bool high);
368	bool updateCurrentRouterConfig(RouterConfig&);
369	bool updateStreamConfig(StreamConfig&, bool low, bool mid, bool high);
370	bool updateStreamConfig(RouterConfig&, StreamConfig&, bool low, bool mid, bool high);
371
372	bool loadFlashConfig();
373	bool storeFlashConfig();
374
375	private:
376	bool loadRouterConfig(bool low, bool mid, bool high);
377	bool loadStreamConfig(bool low, bool mid, bool high);
378	bool loadRouterAndStreamConfig(bool low, bool mid, bool high);
379	private:
380	bool m_router_exposed;
381	bool m_router_readonly;
382	bool m_router_flashstored;
383	uint16_t m_router_nb_entries;
384
385	bool m_mixer_exposed;
386	bool m_mixer_readonly;
387	bool m_mixer_flashstored;
388	uint8_t m_mixer_tx_id;
389	uint8_t m_mixer_rx_id;
390	uint8_t m_mixer_nb_tx;
391	uint8_t m_mixer_nb_rx;
392
393	bool m_general_support_dynstream;
394	bool m_general_support_flash;
395	bool m_general_peak_enabled;
396	uint8_t m_general_max_tx;
397	uint8_t m_general_max_rx;
398	bool m_general_stream_cfg_stored;
399	uint16_t m_general_chip;
400
401	bool commandHelper(fb_quadlet_t cmd);
402
403	bool readReg(enum eRegBase, unsigned offset, quadlet_t *);
404	bool writeReg(enum eRegBase, unsigned offset, quadlet_t);
405	bool readRegBlock(enum eRegBase, unsigned, fb_quadlet_t *, size_t);
406	bool writeRegBlock(enum eRegBase, unsigned, fb_quadlet_t *, size_t);
407	bool readRegBlockSwapped(enum eRegBase, unsigned, fb_quadlet_t *, size_t);
408	bool writeRegBlockSwapped(enum eRegBase, unsigned, fb_quadlet_t *, size_t);
409	fb_nodeaddr_t offsetGen(enum eRegBase, unsigned, size_t);
410
411	private:
412	DECLARE_DEBUG_MODULE_REFERENCE;
413
414	private:
415	Device & m_device;
416	Mixer* m_mixer;
417	Router* m_router;
418	RouterConfig m_current_cfg_routing_low;
419	RouterConfig m_current_cfg_routing_mid;
420	RouterConfig m_current_cfg_routing_high;
421	StreamConfig m_current_cfg_stream_low;
422	StreamConfig m_current_cfg_stream_mid;
423	StreamConfig m_current_cfg_stream_high;
424	public:
425	Mixer* getMixer() {return m_mixer;};
426	Router* getRouter() {return m_router;};
427
428	private:
429
430	fb_quadlet_t m_capability_offset;
431	fb_quadlet_t m_capability_size;
432	fb_quadlet_t m_cmd_offset;
433	fb_quadlet_t m_cmd_size;
434	fb_quadlet_t m_mixer_offset;
435	fb_quadlet_t m_mixer_size;
436	fb_quadlet_t m_peak_offset;
437	fb_quadlet_t m_peak_size;
438	fb_quadlet_t m_new_routing_offset;
439	fb_quadlet_t m_new_routing_size;
440	fb_quadlet_t m_new_stream_cfg_offset;
441	fb_quadlet_t m_new_stream_cfg_size;
442	fb_quadlet_t m_curr_cfg_offset;
443	fb_quadlet_t m_curr_cfg_size;
444	fb_quadlet_t m_standalone_offset;
445	fb_quadlet_t m_standalone_size;
446	fb_quadlet_t m_app_offset;
447	fb_quadlet_t m_app_size;
448	};
449
450	public:
451	Device( DeviceManager& d, std::auto_ptr<ConfigRom>( configRom ));
452	~Device();
453
454	static bool probe( Util::Configuration& c, ConfigRom& configRom, bool generic = false );
455	static FFADODevice * createDevice( DeviceManager& d, std::auto_ptr<ConfigRom>( configRom ));
456	virtual bool discover();
457
458	static int getConfigurationId( );
459
460	virtual void showDevice();
461
462	virtual bool setSamplingFrequency( int samplingFrequency );
463	virtual int getSamplingFrequency( );
464	virtual std::vector<int> getSupportedSamplingFrequencies();
465
466	virtual ClockSourceVector getSupportedClockSources();
467	virtual bool setActiveClockSource(ClockSource);
468	virtual ClockSource getActiveClockSource();
469
470	virtual int getStreamCount();
471	virtual Streaming::StreamProcessor *getStreamProcessorByIndex(int i);
472
473	virtual bool prepare();
474
475	virtual bool lock();
476	virtual bool unlock();
477
478	virtual bool startStreamByIndex(int i);
479	virtual bool stopStreamByIndex(int i);
480
481	virtual bool enableStreaming();
482	virtual bool disableStreaming();
483
484	virtual std::string getNickname();
485	virtual bool setNickname(std::string name);
486
487	protected:
488	// streaming stuff
489	typedef std::vector< Streaming::StreamProcessor * > StreamProcessorVector;
490	typedef std::vector< Streaming::StreamProcessor * >::iterator StreamProcessorVectorIterator;
491	StreamProcessorVector m_receiveProcessors;
492	StreamProcessorVector m_transmitProcessors;
493
494	private: // streaming & port helpers
495	enum EPortTypes {
496	ePT_Analog,
497	ePT_MIDI,
498	};
499
500	typedef struct {
501	std::string name;
502	enum EPortTypes portType;
503	unsigned int streamPosition;
504	unsigned int streamLocation;
505	} diceChannelInfo;
506
507	bool addChannelToProcessor( diceChannelInfo *,
508	Streaming::StreamProcessor *,
509	Streaming::Port::E_Direction direction);
510
511	int allocateIsoChannel(unsigned int packet_size);
512	bool deallocateIsoChannel(int channel);
513
514	private: // active config
515	enum eDiceConfig {
516	eDC_Unknown,
517	eDC_Low,
518	eDC_Mid,
519	eDC_High,
520	};
521
522	enum eDiceConfig getCurrentConfig();
523
524	private: // helper functions
525	bool enableIsoStreaming();
526	bool disableIsoStreaming();
527	bool isIsoStreamingEnabled();
528
529	bool maskedCheckZeroGlobalReg(fb_nodeaddr_t offset, fb_quadlet_t mask);
530	bool maskedCheckNotZeroGlobalReg(fb_nodeaddr_t offset, fb_quadlet_t mask);
531
532	diceNameVector splitNameString(std::string in);
533	diceNameVector getTxNameString(unsigned int i);
534	diceNameVector getRxNameString(unsigned int i);
535	diceNameVector getClockSourceNameString();
536	std::string getDeviceNickName();
537	bool setDeviceNickName(std::string name);
538
539	enum eClockSourceType clockIdToType(unsigned int id);
540	bool isClockSourceIdLocked(unsigned int id, quadlet_t ext_status_reg);
541	bool isClockSourceIdSlipping(unsigned int id, quadlet_t ext_status_reg);
542
543	// EAP stuff
544	private:
545	EAP* m_eap;
546	public:
547	EAP* getEAP() {return m_eap;};
548
549	private: // register I/O routines
550	bool initIoFunctions();
551	// quadlet read/write routines
552	bool readReg(fb_nodeaddr_t, fb_quadlet_t *);
553	bool writeReg(fb_nodeaddr_t, fb_quadlet_t);
554	bool readRegBlock(fb_nodeaddr_t, fb_quadlet_t *, size_t);
555	bool writeRegBlock(fb_nodeaddr_t, fb_quadlet_t *, size_t);
556
557	bool readGlobalReg(fb_nodeaddr_t, fb_quadlet_t *);
558	bool writeGlobalReg(fb_nodeaddr_t, fb_quadlet_t);
559	bool readGlobalRegBlock(fb_nodeaddr_t, fb_quadlet_t *, size_t);
560	bool writeGlobalRegBlock(fb_nodeaddr_t, fb_quadlet_t *, size_t);
561	fb_nodeaddr_t globalOffsetGen(fb_nodeaddr_t, size_t);
562
563	bool readTxReg(unsigned int i, fb_nodeaddr_t, fb_quadlet_t *);
564	bool writeTxReg(unsigned int i, fb_nodeaddr_t, fb_quadlet_t);
565	bool readTxRegBlock(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length);
566	bool writeTxRegBlock(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length);
567	fb_nodeaddr_t txOffsetGen(unsigned int, fb_nodeaddr_t, size_t);
568
569	bool readRxReg(unsigned int i, fb_nodeaddr_t, fb_quadlet_t *);
570	bool writeRxReg(unsigned int i, fb_nodeaddr_t, fb_quadlet_t);
571	bool readRxRegBlock(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length);
572	bool writeRxRegBlock(unsigned int i, fb_nodeaddr_t offset, fb_quadlet_t *data, size_t length);
573	fb_nodeaddr_t rxOffsetGen(unsigned int, fb_nodeaddr_t, size_t);
574
575	fb_quadlet_t m_global_reg_offset;
576	fb_quadlet_t m_global_reg_size;
577	fb_quadlet_t m_tx_reg_offset;
578	fb_quadlet_t m_tx_reg_size;
579	fb_quadlet_t m_rx_reg_offset;
580	fb_quadlet_t m_rx_reg_size;
581	fb_quadlet_t m_unused1_reg_offset;
582	fb_quadlet_t m_unused1_reg_size;
583	fb_quadlet_t m_unused2_reg_offset;
584	fb_quadlet_t m_unused2_reg_size;
585
586	fb_quadlet_t m_nb_tx;
587	fb_quadlet_t m_tx_size;
588	fb_quadlet_t m_nb_rx;
589	fb_quadlet_t m_rx_size;
590
591	// private:
592	public:
593	// notification
594	Notifier *m_notifier;
595
596	/**
597	* this class reacts on the DICE device writing to the
598	* hosts notify address
599	*/
600	#define DICE_NOTIFIER_BASE_ADDRESS 0x0000FFFFE0000000ULL
601	#define DICE_NOTIFIER_BLOCK_LENGTH 4
602	class Notifier : public Ieee1394Service::ARMHandler
603	{
604	public:
605	Notifier(Device &, nodeaddr_t start);
606	virtual ~Notifier();
607
608	private:
609	Device &m_device;
610	};
611
612
613
614	};
615
616	}
617	#endif

Note: See TracBrowser for help on using the browser.

root/trunk/libffado/src/dice/dice_avdevice.h

Download in other formats: