amdtp-stream.h

  1/* SPDX-License-Identifier: GPL-2.0 */
  2#ifndef SOUND_FIREWIRE_AMDTP_H_INCLUDED
  3#define SOUND_FIREWIRE_AMDTP_H_INCLUDED
  4
  5#include <linux/err.h>
  6#include <linux/interrupt.h>
  7#include <linux/mutex.h>
  8#include <linux/sched.h>
  9#include <sound/asound.h>
 10#include "packets-buffer.h"
 11
 12/**
 13 * enum cip_flags - describes details of the streaming protocol
 14 * @CIP_NONBLOCKING: In non-blocking mode, each packet contains
 15 *	sample_rate/8000 samples, with rounding up or down to adjust
 16 *	for clock skew and left-over fractional samples.  This should
 17 *	be used if supported by the device.
 18 * @CIP_BLOCKING: In blocking mode, each packet contains either zero or
 19 *	SYT_INTERVAL samples, with these two types alternating so that
 20 *	the overall sample rate comes out right.
 21 * @CIP_EMPTY_WITH_TAG0: Only for in-stream. Empty in-packets have TAG0.
 22 * @CIP_DBC_IS_END_EVENT: The value of dbc in an packet corresponds to the end
 23 * of event in the packet. Out of IEC 61883.
 24 * @CIP_WRONG_DBS: Only for in-stream. The value of dbs is wrong in in-packets.
 25 *	The value of data_block_quadlets is used instead of reported value.
 26 * @CIP_SKIP_DBC_ZERO_CHECK: Only for in-stream.  Packets with zero in dbc is
 27 *	skipped for detecting discontinuity.
 28 * @CIP_EMPTY_HAS_WRONG_DBC: Only for in-stream. The value of dbc in empty
 29 *	packet is wrong but the others are correct.
 30 * @CIP_JUMBO_PAYLOAD: Only for in-stream. The number of data blocks in an
 31 *	packet is larger than IEC 61883-6 defines. Current implementation
 32 *	allows 5 times as large as IEC 61883-6 defines.
 33 * @CIP_HEADER_WITHOUT_EOH: Only for in-stream. CIP Header doesn't include
 34 *	valid EOH.
 35 * @CIP_NO_HEADER: a lack of headers in packets
 36 * @CIP_UNALIGHED_DBC: Only for in-stream. The value of dbc is not alighed to
 37 *	the value of current SYT_INTERVAL; e.g. initial value is not zero.
 38 * @CIP_UNAWARE_SYT: For outgoing packet, the value in SYT field of CIP is 0xffff.
 39 *	For incoming packet, the value in SYT field of CIP is not handled.
 40 * @CIP_DBC_IS_PAYLOAD_QUADLETS: Available for incoming packet, and only effective with
 41 *	CIP_DBC_IS_END_EVENT flag. The value of dbc field is the number of accumulated quadlets
 42 *	in CIP payload, instead of the number of accumulated data blocks.
 43 */
 44enum cip_flags {
 45	CIP_NONBLOCKING		= 0x00,
 46	CIP_BLOCKING		= 0x01,
 47	CIP_EMPTY_WITH_TAG0	= 0x02,
 48	CIP_DBC_IS_END_EVENT	= 0x04,
 49	CIP_WRONG_DBS		= 0x08,
 50	CIP_SKIP_DBC_ZERO_CHECK	= 0x10,
 51	CIP_EMPTY_HAS_WRONG_DBC	= 0x20,
 52	CIP_JUMBO_PAYLOAD	= 0x40,
 53	CIP_HEADER_WITHOUT_EOH	= 0x80,
 54	CIP_NO_HEADER		= 0x100,
 55	CIP_UNALIGHED_DBC	= 0x200,
 56	CIP_UNAWARE_SYT		= 0x400,
 57	CIP_DBC_IS_PAYLOAD_QUADLETS = 0x800,
 58};
 59
 60/**
 61 * enum cip_sfc - supported Sampling Frequency Codes (SFCs)
 62 * @CIP_SFC_32000:   32,000 data blocks
 63 * @CIP_SFC_44100:   44,100 data blocks
 64 * @CIP_SFC_48000:   48,000 data blocks
 65 * @CIP_SFC_88200:   88,200 data blocks
 66 * @CIP_SFC_96000:   96,000 data blocks
 67 * @CIP_SFC_176400: 176,400 data blocks
 68 * @CIP_SFC_192000: 192,000 data blocks
 69 * @CIP_SFC_COUNT: the number of supported SFCs
 70 *
 71 * These values are used to show nominal Sampling Frequency Code in
 72 * Format Dependent Field (FDF) of AMDTP packet header. In IEC 61883-6:2002,
 73 * this code means the number of events per second. Actually the code
 74 * represents the number of data blocks transferred per second in an AMDTP
 75 * stream.
 76 *
 77 * In IEC 61883-6:2005, some extensions were added to support more types of
 78 * data such as 'One Bit LInear Audio', therefore the meaning of SFC became
 79 * different depending on the types.
 80 *
 81 * Currently our implementation is compatible with IEC 61883-6:2002.
 82 */
 83enum cip_sfc {
 84	CIP_SFC_32000  = 0,
 85	CIP_SFC_44100  = 1,
 86	CIP_SFC_48000  = 2,
 87	CIP_SFC_88200  = 3,
 88	CIP_SFC_96000  = 4,
 89	CIP_SFC_176400 = 5,
 90	CIP_SFC_192000 = 6,
 91	CIP_SFC_COUNT
 92};
 93
 94struct fw_unit;
 95struct fw_iso_context;
 96struct snd_pcm_substream;
 97struct snd_pcm_runtime;
 98
 99enum amdtp_stream_direction {
100	AMDTP_OUT_STREAM = 0,
101	AMDTP_IN_STREAM
102};
103
104struct pkt_desc {
105	u32 cycle;
106	u32 syt;
107	unsigned int data_blocks;
108	unsigned int data_block_counter;
109	__be32 *ctx_payload;
110	struct list_head link;
111};
112
113struct amdtp_stream;
114typedef void (*amdtp_stream_process_ctx_payloads_t)(struct amdtp_stream *s,
115						    const struct pkt_desc *desc,
116						    unsigned int count,
117						    struct snd_pcm_substream *pcm);
118
119struct amdtp_domain;
120struct amdtp_stream {
121	struct fw_unit *unit;
122	// The combination of cip_flags enumeration-constants.
123	unsigned int flags;
124	enum amdtp_stream_direction direction;
125	struct mutex mutex;
126
127	/* For packet processing. */
128	struct fw_iso_context *context;
129	struct iso_packets_buffer buffer;
130	unsigned int queue_size;
131	int packet_index;
132	struct pkt_desc *packet_descs;
133	struct list_head packet_descs_list;
134	struct pkt_desc *packet_descs_cursor;
135	int tag;
136	union {
137		struct {
138			unsigned int ctx_header_size;
139
140			// limit for payload of iso packet.
141			unsigned int max_ctx_payload_length;
142
143			// For quirks of CIP headers.
144			// Fixed interval of dbc between previos/current
145			// packets.
146			unsigned int dbc_interval;
147
148			// The device starts multiplexing events to the packet.
149			bool event_starts;
150
151			struct {
152				struct seq_desc *descs;
153				unsigned int size;
154				unsigned int pos;
155			} cache;
156		} tx;
157		struct {
158			// To generate CIP header.
159			unsigned int fdf;
160
161			// To generate constant hardware IRQ.
162			unsigned int event_count;
163
164			// To calculate CIP data blocks and tstamp.
165			struct {
166				struct seq_desc *descs;
167				unsigned int size;
168				unsigned int pos;
169			} seq;
170
171			unsigned int data_block_state;
172			unsigned int syt_offset_state;
173			unsigned int last_syt_offset;
174
175			struct amdtp_stream *replay_target;
176			unsigned int cache_pos;
177		} rx;
178	} ctx_data;
179
180	/* For CIP headers. */
181	unsigned int source_node_id_field;
182	unsigned int data_block_quadlets;
183	unsigned int data_block_counter;
184	unsigned int sph;
185	unsigned int fmt;
186
187	// Internal flags.
188	unsigned int transfer_delay;
189	enum cip_sfc sfc;
190	unsigned int syt_interval;
191
192	/* For a PCM substream processing. */
193	struct snd_pcm_substream *pcm;
194	struct work_struct period_work;
195	snd_pcm_uframes_t pcm_buffer_pointer;
196	unsigned int pcm_period_pointer;
197	unsigned int pcm_frame_multiplier;
198
199	// To start processing content of packets at the same cycle in several contexts for
200	// each direction.
201	bool ready_processing;
202	wait_queue_head_t ready_wait;
203	unsigned int next_cycle;
204
205	/* For backends to process data blocks. */
206	void *protocol;
207	amdtp_stream_process_ctx_payloads_t process_ctx_payloads;
208
209	// For domain.
210	int channel;
211	int speed;
212	struct list_head list;
213	struct amdtp_domain *domain;
214};
215
216int amdtp_stream_init(struct amdtp_stream *s, struct fw_unit *unit,
217		      enum amdtp_stream_direction dir, unsigned int flags,
218		      unsigned int fmt,
219		      amdtp_stream_process_ctx_payloads_t process_ctx_payloads,
220		      unsigned int protocol_size);
221void amdtp_stream_destroy(struct amdtp_stream *s);
222
223int amdtp_stream_set_parameters(struct amdtp_stream *s, unsigned int rate,
224				unsigned int data_block_quadlets, unsigned int pcm_frame_multiplier);
225unsigned int amdtp_stream_get_max_payload(struct amdtp_stream *s);
226
227void amdtp_stream_update(struct amdtp_stream *s);
228
229int amdtp_stream_add_pcm_hw_constraints(struct amdtp_stream *s,
230					struct snd_pcm_runtime *runtime);
231
232void amdtp_stream_pcm_prepare(struct amdtp_stream *s);
233void amdtp_stream_pcm_abort(struct amdtp_stream *s);
234
235extern const unsigned int amdtp_syt_intervals[CIP_SFC_COUNT];
236extern const unsigned int amdtp_rate_table[CIP_SFC_COUNT];
237
238/**
239 * amdtp_stream_running - check stream is running or not
240 * @s: the AMDTP stream
241 *
242 * If this function returns true, the stream is running.
243 */
244static inline bool amdtp_stream_running(struct amdtp_stream *s)
245{
246	return !IS_ERR(s->context);
247}
248
249/**
250 * amdtp_streaming_error - check for streaming error
251 * @s: the AMDTP stream
252 *
253 * If this function returns true, the stream's packet queue has stopped due to
254 * an asynchronous error.
255 */
256static inline bool amdtp_streaming_error(struct amdtp_stream *s)
257{
258	return s->packet_index < 0;
259}
260
261/**
262 * amdtp_stream_pcm_running - check PCM substream is running or not
263 * @s: the AMDTP stream
264 *
265 * If this function returns true, PCM substream in the AMDTP stream is running.
266 */
267static inline bool amdtp_stream_pcm_running(struct amdtp_stream *s)
268{
269	return !!s->pcm;
270}
271
272/**
273 * amdtp_stream_pcm_trigger - start/stop playback from a PCM device
274 * @s: the AMDTP stream
275 * @pcm: the PCM device to be started, or %NULL to stop the current device
276 *
277 * Call this function on a running isochronous stream to enable the actual
278 * transmission of PCM data.  This function should be called from the PCM
279 * device's .trigger callback.
280 */
281static inline void amdtp_stream_pcm_trigger(struct amdtp_stream *s,
282					    struct snd_pcm_substream *pcm)
283{
284	WRITE_ONCE(s->pcm, pcm);
285}
286
287/**
288 * amdtp_stream_next_packet_desc - retrieve next descriptor for amdtp packet.
289 * @s: the AMDTP stream
290 * @desc: the descriptor of packet
291 *
292 * This macro computes next descriptor so that the list of descriptors behaves circular queue.
293 */
294#define amdtp_stream_next_packet_desc(s, desc) \
295	list_next_entry_circular(desc, &s->packet_descs_list, link)
296
297static inline bool cip_sfc_is_base_44100(enum cip_sfc sfc)
298{
299	return sfc & 1;
300}
301
302struct seq_desc {
303	unsigned int syt_offset;
304	unsigned int data_blocks;
305};
306
307struct amdtp_domain {
308	struct list_head streams;
309
310	unsigned int events_per_period;
311	unsigned int events_per_buffer;
312
313	struct amdtp_stream *irq_target;
314
315	struct {
316		unsigned int tx_init_skip;
317		unsigned int tx_start;
318		unsigned int rx_start;
319	} processing_cycle;
320
321	struct {
322		bool enable:1;
323		bool on_the_fly:1;
324	} replay;
325};
326
327int amdtp_domain_init(struct amdtp_domain *d);
328void amdtp_domain_destroy(struct amdtp_domain *d);
329
330int amdtp_domain_add_stream(struct amdtp_domain *d, struct amdtp_stream *s,
331			    int channel, int speed);
332
333int amdtp_domain_start(struct amdtp_domain *d, unsigned int tx_init_skip_cycles, bool replay_seq,
334		       bool replay_on_the_fly);
335void amdtp_domain_stop(struct amdtp_domain *d);
336
337static inline int amdtp_domain_set_events_per_period(struct amdtp_domain *d,
338						unsigned int events_per_period,
339						unsigned int events_per_buffer)
340{
341	d->events_per_period = events_per_period;
342	d->events_per_buffer = events_per_buffer;
343
344	return 0;
345}
346
347unsigned long amdtp_domain_stream_pcm_pointer(struct amdtp_domain *d,
348					      struct amdtp_stream *s);
349int amdtp_domain_stream_pcm_ack(struct amdtp_domain *d, struct amdtp_stream *s);
350
351/**
352 * amdtp_domain_wait_ready - sleep till being ready to process packets or timeout
353 * @d: the AMDTP domain
354 * @timeout_ms: msec till timeout
355 *
356 * If this function return false, the AMDTP domain should be stopped.
357 */
358static inline bool amdtp_domain_wait_ready(struct amdtp_domain *d, unsigned int timeout_ms)
359{
360	struct amdtp_stream *s;
361
362	list_for_each_entry(s, &d->streams, list) {
363		unsigned int j = msecs_to_jiffies(timeout_ms);
364
365		if (wait_event_interruptible_timeout(s->ready_wait, s->ready_processing, j) <= 0)
366			return false;
367	}
368
369	return true;
370}
371
372#endif