amdtp.c 26.3 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
/*
 * Audio and Music Data Transmission Protocol (IEC 61883-6) streams
 * with Common Isochronous Packet (IEC 61883-1) headers
 *
 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
 * Licensed under the terms of the GNU General Public License, version 2.
 */

#include <linux/device.h>
#include <linux/err.h>
#include <linux/firewire.h>
#include <linux/module.h>
#include <linux/slab.h>
14
#include <linux/sched.h>
15
#include <sound/pcm.h>
16
#include <sound/pcm_params.h>
17
#include <sound/rawmidi.h>
18
19
20
21
22
23
24
25
#include "amdtp.h"

#define TICKS_PER_CYCLE		3072
#define CYCLES_PER_SECOND	8000
#define TICKS_PER_SECOND	(TICKS_PER_CYCLE * CYCLES_PER_SECOND)

#define TRANSFER_DELAY_TICKS	0x2e00 /* 479.17 µs */

26
27
/* isochronous header parameters */
#define ISO_DATA_LENGTH_SHIFT	16
28
29
#define TAG_CIP			1

30
/* common isochronous packet header parameters */
31
#define CIP_EOH			(1u << 31)
32
#define CIP_EOH_MASK		0x80000000
33
#define CIP_FMT_AM		(0x10 << 24)
34
35
36
37
38
39
40
41
42
43
44
#define CIP_FMT_MASK		0x3f000000
#define CIP_SYT_MASK		0x0000ffff
#define CIP_SYT_NO_INFO		0xffff
#define CIP_FDF_MASK		0x00ff0000
#define CIP_FDF_SFC_SHIFT	16

/*
 * Audio and Music transfer protocol specific parameters
 * only "Clock-based rate control mode" is supported
 */
#define AMDTP_FDF_AM824		(0 << (CIP_FDF_SFC_SHIFT + 3))
45
#define AMDTP_FDF_NO_DATA	0xff
46
47
48
#define AMDTP_DBS_MASK		0x00ff0000
#define AMDTP_DBS_SHIFT		16
#define AMDTP_DBC_MASK		0x000000ff
49
50
51
52
53

/* TODO: make these configurable */
#define INTERRUPT_INTERVAL	16
#define QUEUE_LENGTH		48

54
#define IN_PACKET_HEADER_SIZE	4
55
56
#define OUT_PACKET_HEADER_SIZE	0

57
58
static void pcm_period_tasklet(unsigned long data);

59
/**
60
61
 * amdtp_stream_init - initialize an AMDTP stream structure
 * @s: the AMDTP stream to initialize
62
 * @unit: the target of the stream
63
 * @dir: the direction of stream
64
65
 * @flags: the packet transmission method to use
 */
66
int amdtp_stream_init(struct amdtp_stream *s, struct fw_unit *unit,
67
		      enum amdtp_stream_direction dir, enum cip_flags flags)
68
69
{
	s->unit = fw_unit_get(unit);
70
	s->direction = dir;
71
72
73
	s->flags = flags;
	s->context = ERR_PTR(-1);
	mutex_init(&s->mutex);
74
	tasklet_init(&s->period_tasklet, pcm_period_tasklet, (unsigned long)s);
75
	s->packet_index = 0;
76

77
78
79
80
	init_waitqueue_head(&s->callback_wait);
	s->callbacked = false;
	s->sync_slave = NULL;

81
82
	return 0;
}
83
EXPORT_SYMBOL(amdtp_stream_init);
84
85

/**
86
87
 * amdtp_stream_destroy - free stream resources
 * @s: the AMDTP stream to destroy
88
 */
89
void amdtp_stream_destroy(struct amdtp_stream *s)
90
{
91
	WARN_ON(amdtp_stream_running(s));
92
93
94
	mutex_destroy(&s->mutex);
	fw_unit_put(s->unit);
}
95
EXPORT_SYMBOL(amdtp_stream_destroy);
96

97
const unsigned int amdtp_syt_intervals[CIP_SFC_COUNT] = {
98
99
100
101
102
103
104
105
106
107
	[CIP_SFC_32000]  =  8,
	[CIP_SFC_44100]  =  8,
	[CIP_SFC_48000]  =  8,
	[CIP_SFC_88200]  = 16,
	[CIP_SFC_96000]  = 16,
	[CIP_SFC_176400] = 32,
	[CIP_SFC_192000] = 32,
};
EXPORT_SYMBOL(amdtp_syt_intervals);

108
109
110
111
112
113
114
115
116
117
118
const unsigned int amdtp_rate_table[] = {
	[CIP_SFC_32000]  =  32000,
	[CIP_SFC_44100]  =  44100,
	[CIP_SFC_48000]  =  48000,
	[CIP_SFC_88200]  =  88200,
	[CIP_SFC_96000]  =  96000,
	[CIP_SFC_176400] = 176400,
	[CIP_SFC_192000] = 192000,
};
EXPORT_SYMBOL(amdtp_rate_table);

119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
/**
 * amdtp_stream_add_pcm_hw_constraints - add hw constraints for PCM substream
 * @s:		the AMDTP stream, which must be initialized.
 * @runtime:	the PCM substream runtime
 */
int amdtp_stream_add_pcm_hw_constraints(struct amdtp_stream *s,
					struct snd_pcm_runtime *runtime)
{
	int err;

	/* AM824 in IEC 61883-6 can deliver 24bit data */
	err = snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
	if (err < 0)
		goto end;

	/*
	 * Currently firewire-lib processes 16 packets in one software
	 * interrupt callback. This equals to 2msec but actually the
	 * interval of the interrupts has a jitter.
	 * Additionally, even if adding a constraint to fit period size to
	 * 2msec, actual calculated frames per period doesn't equal to 2msec,
	 * depending on sampling rate.
	 * Anyway, the interval to call snd_pcm_period_elapsed() cannot 2msec.
	 * Here let us use 5msec for safe period interrupt.
	 */
	err = snd_pcm_hw_constraint_minmax(runtime,
					   SNDRV_PCM_HW_PARAM_PERIOD_TIME,
					   5000, UINT_MAX);
	if (err < 0)
		goto end;

	/* Non-Blocking stream has no more constraints */
	if (!(s->flags & CIP_BLOCKING))
		goto end;

	/*
	 * One AMDTP packet can include some frames. In blocking mode, the
	 * number equals to SYT_INTERVAL. So the number is 8, 16 or 32,
	 * depending on its sampling rate. For accurate period interrupt, it's
	 * preferrable to aligh period/buffer sizes to current SYT_INTERVAL.
	 *
	 * TODO: These constraints can be improved with propper rules.
	 * Currently apply LCM of SYT_INTEVALs.
	 */
	err = snd_pcm_hw_constraint_step(runtime, 0,
					 SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 32);
	if (err < 0)
		goto end;
	err = snd_pcm_hw_constraint_step(runtime, 0,
					 SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 32);
end:
	return err;
}
EXPORT_SYMBOL(amdtp_stream_add_pcm_hw_constraints);

174
/**
175
176
 * amdtp_stream_set_parameters - set stream parameters
 * @s: the AMDTP stream to configure
177
 * @rate: the sample rate
178
179
180
 * @pcm_channels: the number of PCM samples in each data block, to be encoded
 *                as AM824 multi-bit linear audio
 * @midi_ports: the number of MIDI ports (i.e., MPX-MIDI Data Channels)
181
 *
182
 * The parameters must be set before the stream is started, and must not be
183
184
 * changed while the stream is running.
 */
185
186
187
188
void amdtp_stream_set_parameters(struct amdtp_stream *s,
				 unsigned int rate,
				 unsigned int pcm_channels,
				 unsigned int midi_ports)
189
{
190
	unsigned int i, sfc, midi_channels;
191

192
193
	midi_channels = DIV_ROUND_UP(midi_ports, 8);

194
195
	if (WARN_ON(amdtp_stream_running(s)) |
	    WARN_ON(pcm_channels > AMDTP_MAX_CHANNELS_FOR_PCM) |
196
	    WARN_ON(midi_channels > AMDTP_MAX_CHANNELS_FOR_MIDI))
197
198
		return;

199
200
	for (sfc = 0; sfc < sizeof(amdtp_rate_table); ++sfc)
		if (amdtp_rate_table[sfc] == rate)
201
			goto sfc_found;
202
	WARN_ON(1);
203
204
205
	return;

sfc_found:
206
	s->pcm_channels = pcm_channels;
207
	s->sfc = sfc;
208
	s->data_block_quadlets = s->pcm_channels + midi_channels;
209
210
211
	s->midi_ports = midi_ports;

	s->syt_interval = amdtp_syt_intervals[sfc];
212
213
214
215
216
217

	/* default buffering in the device */
	s->transfer_delay = TRANSFER_DELAY_TICKS - TICKS_PER_CYCLE;
	if (s->flags & CIP_BLOCKING)
		/* additional buffering needed to adjust for no-data packets */
		s->transfer_delay += TICKS_PER_SECOND * s->syt_interval / rate;
218
219
220
221
222

	/* init the position map for PCM and MIDI channels */
	for (i = 0; i < pcm_channels; i++)
		s->pcm_positions[i] = i;
	s->midi_position = s->pcm_channels;
223
}
224
EXPORT_SYMBOL(amdtp_stream_set_parameters);
225
226

/**
227
228
 * amdtp_stream_get_max_payload - get the stream's packet size
 * @s: the AMDTP stream
229
230
 *
 * This function must not be called before the stream has been configured
231
 * with amdtp_stream_set_parameters().
232
 */
233
unsigned int amdtp_stream_get_max_payload(struct amdtp_stream *s)
234
{
235
	return 8 + s->syt_interval * s->data_block_quadlets * 4;
236
}
237
EXPORT_SYMBOL(amdtp_stream_get_max_payload);
238

239
static void amdtp_write_s16(struct amdtp_stream *s,
240
241
			    struct snd_pcm_substream *pcm,
			    __be32 *buffer, unsigned int frames);
242
static void amdtp_write_s32(struct amdtp_stream *s,
243
244
			    struct snd_pcm_substream *pcm,
			    __be32 *buffer, unsigned int frames);
245
246
247
static void amdtp_read_s32(struct amdtp_stream *s,
			   struct snd_pcm_substream *pcm,
			   __be32 *buffer, unsigned int frames);
248
249

/**
250
251
 * amdtp_stream_set_pcm_format - set the PCM format
 * @s: the AMDTP stream to configure
252
253
 * @format: the format of the ALSA PCM device
 *
254
255
256
 * The sample format must be set after the other paramters (rate/PCM channels/
 * MIDI) and before the stream is started, and must not be changed while the
 * stream is running.
257
 */
258
259
void amdtp_stream_set_pcm_format(struct amdtp_stream *s,
				 snd_pcm_format_t format)
260
{
261
	if (WARN_ON(amdtp_stream_pcm_running(s)))
262
263
264
265
266
267
268
		return;

	switch (format) {
	default:
		WARN_ON(1);
		/* fall through */
	case SNDRV_PCM_FORMAT_S16:
269
		if (s->direction == AMDTP_OUT_STREAM) {
270
			s->transfer_samples = amdtp_write_s16;
271
272
273
274
			break;
		}
		WARN_ON(1);
		/* fall through */
275
	case SNDRV_PCM_FORMAT_S32:
276
277
278
279
		if (s->direction == AMDTP_OUT_STREAM)
			s->transfer_samples = amdtp_write_s32;
		else
			s->transfer_samples = amdtp_read_s32;
280
281
282
		break;
	}
}
283
EXPORT_SYMBOL(amdtp_stream_set_pcm_format);
284

285
/**
286
287
 * amdtp_stream_pcm_prepare - prepare PCM device for running
 * @s: the AMDTP stream
288
289
290
 *
 * This function should be called from the PCM device's .prepare callback.
 */
291
void amdtp_stream_pcm_prepare(struct amdtp_stream *s)
292
293
294
295
{
	tasklet_kill(&s->period_tasklet);
	s->pcm_buffer_pointer = 0;
	s->pcm_period_pointer = 0;
296
	s->pointer_flush = true;
297
}
298
EXPORT_SYMBOL(amdtp_stream_pcm_prepare);
299

300
static unsigned int calculate_data_blocks(struct amdtp_stream *s)
301
302
303
{
	unsigned int phase, data_blocks;

304
305
306
	if (s->flags & CIP_BLOCKING)
		data_blocks = s->syt_interval;
	else if (!cip_sfc_is_base_44100(s->sfc)) {
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
		/* Sample_rate / 8000 is an integer, and precomputed. */
		data_blocks = s->data_block_state;
	} else {
		phase = s->data_block_state;

		/*
		 * This calculates the number of data blocks per packet so that
		 * 1) the overall rate is correct and exactly synchronized to
		 *    the bus clock, and
		 * 2) packets with a rounded-up number of blocks occur as early
		 *    as possible in the sequence (to prevent underruns of the
		 *    device's buffer).
		 */
		if (s->sfc == CIP_SFC_44100)
			/* 6 6 5 6 5 6 5 ... */
			data_blocks = 5 + ((phase & 1) ^
					   (phase == 0 || phase >= 40));
		else
			/* 12 11 11 11 11 ... or 23 22 22 22 22 ... */
			data_blocks = 11 * (s->sfc >> 1) + (phase == 0);
		if (++phase >= (80 >> (s->sfc >> 1)))
			phase = 0;
		s->data_block_state = phase;
	}

	return data_blocks;
}

335
static unsigned int calculate_syt(struct amdtp_stream *s,
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
				  unsigned int cycle)
{
	unsigned int syt_offset, phase, index, syt;

	if (s->last_syt_offset < TICKS_PER_CYCLE) {
		if (!cip_sfc_is_base_44100(s->sfc))
			syt_offset = s->last_syt_offset + s->syt_offset_state;
		else {
		/*
		 * The time, in ticks, of the n'th SYT_INTERVAL sample is:
		 *   n * SYT_INTERVAL * 24576000 / sample_rate
		 * Modulo TICKS_PER_CYCLE, the difference between successive
		 * elements is about 1386.23.  Rounding the results of this
		 * formula to the SYT precision results in a sequence of
		 * differences that begins with:
		 *   1386 1386 1387 1386 1386 1386 1387 1386 1386 1386 1387 ...
		 * This code generates _exactly_ the same sequence.
		 */
			phase = s->syt_offset_state;
			index = phase % 13;
			syt_offset = s->last_syt_offset;
			syt_offset += 1386 + ((index && !(index & 3)) ||
					      phase == 146);
			if (++phase >= 147)
				phase = 0;
			s->syt_offset_state = phase;
		}
	} else
		syt_offset = s->last_syt_offset - TICKS_PER_CYCLE;
	s->last_syt_offset = syt_offset;

367
	if (syt_offset < TICKS_PER_CYCLE) {
368
		syt_offset += s->transfer_delay;
369
370
		syt = (cycle + syt_offset / TICKS_PER_CYCLE) << 12;
		syt += syt_offset % TICKS_PER_CYCLE;
371

372
		return syt & CIP_SYT_MASK;
373
	} else {
374
		return CIP_SYT_NO_INFO;
375
	}
376
377
}

378
static void amdtp_write_s32(struct amdtp_stream *s,
379
380
381
382
			    struct snd_pcm_substream *pcm,
			    __be32 *buffer, unsigned int frames)
{
	struct snd_pcm_runtime *runtime = pcm->runtime;
383
	unsigned int channels, remaining_frames, i, c;
384
385
386
387
	const u32 *src;

	channels = s->pcm_channels;
	src = (void *)runtime->dma_area +
388
			frames_to_bytes(runtime, s->pcm_buffer_pointer);
389
390
391
392
	remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;

	for (i = 0; i < frames; ++i) {
		for (c = 0; c < channels; ++c) {
393
394
			buffer[s->pcm_positions[c]] =
					cpu_to_be32((*src >> 8) | 0x40000000);
395
396
			src++;
		}
397
		buffer += s->data_block_quadlets;
398
399
400
401
402
		if (--remaining_frames == 0)
			src = (void *)runtime->dma_area;
	}
}

403
static void amdtp_write_s16(struct amdtp_stream *s,
404
405
406
407
			    struct snd_pcm_substream *pcm,
			    __be32 *buffer, unsigned int frames)
{
	struct snd_pcm_runtime *runtime = pcm->runtime;
408
	unsigned int channels, remaining_frames, i, c;
409
410
411
412
	const u16 *src;

	channels = s->pcm_channels;
	src = (void *)runtime->dma_area +
413
			frames_to_bytes(runtime, s->pcm_buffer_pointer);
414
415
416
417
	remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;

	for (i = 0; i < frames; ++i) {
		for (c = 0; c < channels; ++c) {
418
419
			buffer[s->pcm_positions[c]] =
					cpu_to_be32((*src << 8) | 0x40000000);
420
421
			src++;
		}
422
		buffer += s->data_block_quadlets;
423
424
425
426
427
		if (--remaining_frames == 0)
			src = (void *)runtime->dma_area;
	}
}

428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
static void amdtp_read_s32(struct amdtp_stream *s,
			   struct snd_pcm_substream *pcm,
			   __be32 *buffer, unsigned int frames)
{
	struct snd_pcm_runtime *runtime = pcm->runtime;
	unsigned int channels, remaining_frames, i, c;
	u32 *dst;

	channels = s->pcm_channels;
	dst  = (void *)runtime->dma_area +
			frames_to_bytes(runtime, s->pcm_buffer_pointer);
	remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;

	for (i = 0; i < frames; ++i) {
		for (c = 0; c < channels; ++c) {
443
			*dst = be32_to_cpu(buffer[s->pcm_positions[c]]) << 8;
444
445
446
447
448
449
450
451
			dst++;
		}
		buffer += s->data_block_quadlets;
		if (--remaining_frames == 0)
			dst = (void *)runtime->dma_area;
	}
}

452
static void amdtp_fill_pcm_silence(struct amdtp_stream *s,
453
454
455
456
457
458
				   __be32 *buffer, unsigned int frames)
{
	unsigned int i, c;

	for (i = 0; i < frames; ++i) {
		for (c = 0; c < s->pcm_channels; ++c)
459
			buffer[s->pcm_positions[c]] = cpu_to_be32(0x40000000);
460
461
462
463
		buffer += s->data_block_quadlets;
	}
}

464
static void amdtp_fill_midi(struct amdtp_stream *s,
465
466
			    __be32 *buffer, unsigned int frames)
{
467
468
469
470
	unsigned int f, port;
	u8 *b;

	for (f = 0; f < frames; f++) {
471
472
		buffer[s->midi_position] = 0;
		b = (u8 *)&buffer[s->midi_position];
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493

		port = (s->data_block_counter + f) % 8;
		if ((s->midi[port] == NULL) ||
		    (snd_rawmidi_transmit(s->midi[port], b + 1, 1) <= 0))
			b[0] = 0x80;
		else
			b[0] = 0x81;

		buffer += s->data_block_quadlets;
	}
}

static void amdtp_pull_midi(struct amdtp_stream *s,
			    __be32 *buffer, unsigned int frames)
{
	unsigned int f, port;
	int len;
	u8 *b;

	for (f = 0; f < frames; f++) {
		port = (s->data_block_counter + f) % 8;
494
		b = (u8 *)&buffer[s->midi_position];
495

496
497
498
499
500
501
		len = b[0] - 0x80;
		if ((1 <= len) &&  (len <= 3) && (s->midi[port]))
			snd_rawmidi_receive(s->midi[port], b + 1, len);

		buffer += s->data_block_quadlets;
	}
502
503
}

504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
static void update_pcm_pointers(struct amdtp_stream *s,
				struct snd_pcm_substream *pcm,
				unsigned int frames)
{	unsigned int ptr;

	ptr = s->pcm_buffer_pointer + frames;
	if (ptr >= pcm->runtime->buffer_size)
		ptr -= pcm->runtime->buffer_size;
	ACCESS_ONCE(s->pcm_buffer_pointer) = ptr;

	s->pcm_period_pointer += frames;
	if (s->pcm_period_pointer >= pcm->runtime->period_size) {
		s->pcm_period_pointer -= pcm->runtime->period_size;
		s->pointer_flush = false;
		tasklet_hi_schedule(&s->period_tasklet);
	}
}

static void pcm_period_tasklet(unsigned long data)
{
	struct amdtp_stream *s = (void *)data;
	struct snd_pcm_substream *pcm = ACCESS_ONCE(s->pcm);

	if (pcm)
		snd_pcm_period_elapsed(pcm);
}

static int queue_packet(struct amdtp_stream *s,
			unsigned int header_length,
			unsigned int payload_length, bool skip)
{
	struct fw_iso_packet p = {0};
536
537
538
539
	int err = 0;

	if (IS_ERR(s->context))
		goto end;
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565

	p.interrupt = IS_ALIGNED(s->packet_index + 1, INTERRUPT_INTERVAL);
	p.tag = TAG_CIP;
	p.header_length = header_length;
	p.payload_length = (!skip) ? payload_length : 0;
	p.skip = skip;
	err = fw_iso_context_queue(s->context, &p, &s->buffer.iso_buffer,
				   s->buffer.packets[s->packet_index].offset);
	if (err < 0) {
		dev_err(&s->unit->device, "queueing error: %d\n", err);
		goto end;
	}

	if (++s->packet_index >= QUEUE_LENGTH)
		s->packet_index = 0;
end:
	return err;
}

static inline int queue_out_packet(struct amdtp_stream *s,
				   unsigned int payload_length, bool skip)
{
	return queue_packet(s, OUT_PACKET_HEADER_SIZE,
			    payload_length, skip);
}

566
567
568
569
570
571
static inline int queue_in_packet(struct amdtp_stream *s)
{
	return queue_packet(s, IN_PACKET_HEADER_SIZE,
			    amdtp_stream_get_max_payload(s), false);
}

572
static void handle_out_packet(struct amdtp_stream *s, unsigned int syt)
573
574
{
	__be32 *buffer;
575
	unsigned int data_blocks, payload_length;
576
577
	struct snd_pcm_substream *pcm;

578
579
580
	if (s->packet_index < 0)
		return;

581
	/* this module generate empty packet for 'no data' */
582
	if (!(s->flags & CIP_BLOCKING) || (syt != CIP_SYT_NO_INFO))
583
		data_blocks = calculate_data_blocks(s);
584
585
	else
		data_blocks = 0;
586

587
	buffer = s->buffer.packets[s->packet_index].buffer;
588
	buffer[0] = cpu_to_be32(ACCESS_ONCE(s->source_node_id_field) |
589
				(s->data_block_quadlets << AMDTP_DBS_SHIFT) |
590
591
				s->data_block_counter);
	buffer[1] = cpu_to_be32(CIP_EOH | CIP_FMT_AM | AMDTP_FDF_AM824 |
592
				(s->sfc << CIP_FDF_SFC_SHIFT) | syt);
593
594
595
596
597
598
599
600
601
602
603
604
	buffer += 2;

	pcm = ACCESS_ONCE(s->pcm);
	if (pcm)
		s->transfer_samples(s, pcm, buffer, data_blocks);
	else
		amdtp_fill_pcm_silence(s, buffer, data_blocks);
	if (s->midi_ports)
		amdtp_fill_midi(s, buffer, data_blocks);

	s->data_block_counter = (s->data_block_counter + data_blocks) & 0xff;

605
606
	payload_length = 8 + data_blocks * 4 * s->data_block_quadlets;
	if (queue_out_packet(s, payload_length, false) < 0) {
607
		s->packet_index = -1;
608
		amdtp_stream_pcm_abort(s);
609
610
		return;
	}
611

612
	if (pcm)
613
		update_pcm_pointers(s, pcm, data_blocks);
614
615
}

616
617
618
619
620
621
622
static void handle_in_packet(struct amdtp_stream *s,
			     unsigned int payload_quadlets,
			     __be32 *buffer)
{
	u32 cip_header[2];
	unsigned int data_blocks, data_block_quadlets, data_block_counter;
	struct snd_pcm_substream *pcm = NULL;
623
	bool lost;
624
625
626
627
628
629

	cip_header[0] = be32_to_cpu(buffer[0]);
	cip_header[1] = be32_to_cpu(buffer[1]);

	/*
	 * This module supports 'Two-quadlet CIP header with SYT field'.
630
	 * For convenience, also check FMT field is AM824 or not.
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
	 */
	if (((cip_header[0] & CIP_EOH_MASK) == CIP_EOH) ||
	    ((cip_header[1] & CIP_EOH_MASK) != CIP_EOH) ||
	    ((cip_header[1] & CIP_FMT_MASK) != CIP_FMT_AM)) {
		dev_info_ratelimited(&s->unit->device,
				"Invalid CIP header for AMDTP: %08X:%08X\n",
				cip_header[0], cip_header[1]);
		goto end;
	}

	/* Calculate data blocks */
	if (payload_quadlets < 3 ||
	    ((cip_header[1] & CIP_FDF_MASK) ==
				(AMDTP_FDF_NO_DATA << CIP_FDF_SFC_SHIFT))) {
		data_blocks = 0;
	} else {
		data_block_quadlets =
			(cip_header[0] & AMDTP_DBS_MASK) >> AMDTP_DBS_SHIFT;
		/* avoid division by zero */
		if (data_block_quadlets == 0) {
			dev_info_ratelimited(&s->unit->device,
				"Detect invalid value in dbs field: %08X\n",
				cip_header[0]);
			goto err;
		}

		data_blocks = (payload_quadlets - 2) / data_block_quadlets;
	}

	/* Check data block counter continuity */
	data_block_counter = cip_header[0] & AMDTP_DBC_MASK;
662
663
664
665
666
667
668
	if (!(s->flags & CIP_DBC_IS_END_EVENT))
		lost = data_block_counter != s->data_block_counter;
	else
		lost = data_block_counter !=
		       ((s->data_block_counter + data_blocks) & 0xff);

	if (lost) {
669
670
671
672
673
674
675
676
677
678
679
680
		dev_info(&s->unit->device,
			 "Detect discontinuity of CIP: %02X %02X\n",
			 s->data_block_counter, data_block_counter);
		goto err;
	}

	if (data_blocks > 0) {
		buffer += 2;

		pcm = ACCESS_ONCE(s->pcm);
		if (pcm)
			s->transfer_samples(s, pcm, buffer, data_blocks);
681
682
683

		if (s->midi_ports)
			amdtp_pull_midi(s, buffer, data_blocks);
684
685
	}

686
687
688
689
690
	if (s->flags & CIP_DBC_IS_END_EVENT)
		s->data_block_counter = data_block_counter;
	else
		s->data_block_counter =
				(data_block_counter + data_blocks) & 0xff;
691
692
693
694
695
696
697
698
699
700
701
702
703
end:
	if (queue_in_packet(s) < 0)
		goto err;

	if (pcm)
		update_pcm_pointers(s, pcm, data_blocks);

	return;
err:
	s->packet_index = -1;
	amdtp_stream_pcm_abort(s);
}

704
705
706
static void out_stream_callback(struct fw_iso_context *context, u32 cycle,
				size_t header_length, void *header,
				void *private_data)
707
{
708
	struct amdtp_stream *s = private_data;
709
	unsigned int i, syt, packets = header_length / 4;
710
711
712
713
714
715
716
717

	/*
	 * Compute the cycle of the last queued packet.
	 * (We need only the four lowest bits for the SYT, so we can ignore
	 * that bits 0-11 must wrap around at 3072.)
	 */
	cycle += QUEUE_LENGTH - packets;

718
719
720
721
	for (i = 0; i < packets; ++i) {
		syt = calculate_syt(s, ++cycle);
		handle_out_packet(s, syt);
	}
722
	fw_iso_context_queue_flush(s->context);
723
724
}

725
726
727
728
729
static void in_stream_callback(struct fw_iso_context *context, u32 cycle,
			       size_t header_length, void *header,
			       void *private_data)
{
	struct amdtp_stream *s = private_data;
730
	unsigned int p, syt, packets, payload_quadlets;
731
732
733
734
735
736
737
	__be32 *buffer, *headers = header;

	/* The number of packets in buffer */
	packets = header_length / IN_PACKET_HEADER_SIZE;

	for (p = 0; p < packets; p++) {
		if (s->packet_index < 0)
738
739
			break;

740
741
		buffer = s->buffer.packets[s->packet_index].buffer;

742
743
744
745
746
747
		/* Process sync slave stream */
		if (s->sync_slave && s->sync_slave->callbacked) {
			syt = be32_to_cpu(buffer[1]) & CIP_SYT_MASK;
			handle_out_packet(s->sync_slave, syt);
		}

748
749
750
751
752
753
		/* The number of quadlets in this packet */
		payload_quadlets =
			(be32_to_cpu(headers[p]) >> ISO_DATA_LENGTH_SHIFT) / 4;
		handle_in_packet(s, payload_quadlets, buffer);
	}

754
755
756
757
758
759
760
761
762
763
764
765
766
767
	/* Queueing error or detecting discontinuity */
	if (s->packet_index < 0) {
		/* Abort sync slave. */
		if (s->sync_slave) {
			s->sync_slave->packet_index = -1;
			amdtp_stream_pcm_abort(s->sync_slave);
		}
		return;
	}

	/* when sync to device, flush the packets for slave stream */
	if (s->sync_slave && s->sync_slave->callbacked)
		fw_iso_context_queue_flush(s->sync_slave->context);

768
769
770
	fw_iso_context_queue_flush(s->context);
}

771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
/* processing is done by master callback */
static void slave_stream_callback(struct fw_iso_context *context, u32 cycle,
				  size_t header_length, void *header,
				  void *private_data)
{
	return;
}

/* this is executed one time */
static void amdtp_stream_first_callback(struct fw_iso_context *context,
					u32 cycle, size_t header_length,
					void *header, void *private_data)
{
	struct amdtp_stream *s = private_data;

	/*
	 * For in-stream, first packet has come.
	 * For out-stream, prepared to transmit first packet
	 */
	s->callbacked = true;
	wake_up(&s->callback_wait);

	if (s->direction == AMDTP_IN_STREAM)
		context->callback.sc = in_stream_callback;
	else if ((s->flags & CIP_BLOCKING) && (s->flags & CIP_SYNC_TO_DEVICE))
		context->callback.sc = slave_stream_callback;
	else
		context->callback.sc = out_stream_callback;

	context->callback.sc(context, cycle, header_length, header, s);
}

803
/**
804
805
 * amdtp_stream_start - start transferring packets
 * @s: the AMDTP stream to start
806
807
808
809
 * @channel: the isochronous channel on the bus
 * @speed: firewire speed code
 *
 * The stream cannot be started until it has been configured with
810
811
 * amdtp_stream_set_parameters() and it must be started before any PCM or MIDI
 * device can be started.
812
 */
813
int amdtp_stream_start(struct amdtp_stream *s, int channel, int speed)
814
815
816
817
818
819
820
821
822
823
824
825
826
{
	static const struct {
		unsigned int data_block;
		unsigned int syt_offset;
	} initial_state[] = {
		[CIP_SFC_32000]  = {  4, 3072 },
		[CIP_SFC_48000]  = {  6, 1024 },
		[CIP_SFC_96000]  = { 12, 1024 },
		[CIP_SFC_192000] = { 24, 1024 },
		[CIP_SFC_44100]  = {  0,   67 },
		[CIP_SFC_88200]  = {  0,   67 },
		[CIP_SFC_176400] = {  0,   67 },
	};
827
828
	unsigned int header_size;
	enum dma_data_direction dir;
829
	int type, tag, err;
830
831
832

	mutex_lock(&s->mutex);

833
	if (WARN_ON(amdtp_stream_running(s) ||
834
		    (s->data_block_quadlets < 1))) {
835
836
837
838
		err = -EBADFD;
		goto err_unlock;
	}

839
	s->data_block_counter = 0;
840
841
842
843
	s->data_block_state = initial_state[s->sfc].data_block;
	s->syt_offset_state = initial_state[s->sfc].syt_offset;
	s->last_syt_offset = TICKS_PER_CYCLE;

844
845
846
847
848
849
850
851
852
853
	/* initialize packet buffer */
	if (s->direction == AMDTP_IN_STREAM) {
		dir = DMA_FROM_DEVICE;
		type = FW_ISO_CONTEXT_RECEIVE;
		header_size = IN_PACKET_HEADER_SIZE;
	} else {
		dir = DMA_TO_DEVICE;
		type = FW_ISO_CONTEXT_TRANSMIT;
		header_size = OUT_PACKET_HEADER_SIZE;
	}
854
	err = iso_packets_buffer_init(&s->buffer, s->unit, QUEUE_LENGTH,
855
				      amdtp_stream_get_max_payload(s), dir);
856
857
858
859
	if (err < 0)
		goto err_unlock;

	s->context = fw_iso_context_create(fw_parent_device(s->unit)->card,
860
					   type, channel, speed, header_size,
861
					   amdtp_stream_first_callback, s);
862
863
864
865
	if (IS_ERR(s->context)) {
		err = PTR_ERR(s->context);
		if (err == -EBUSY)
			dev_err(&s->unit->device,
866
				"no free stream on this controller\n");
867
868
869
		goto err_buffer;
	}

870
	amdtp_stream_update(s);
871

872
	s->packet_index = 0;
873
	do {
874
875
876
877
		if (s->direction == AMDTP_IN_STREAM)
			err = queue_in_packet(s);
		else
			err = queue_out_packet(s, 0, true);
878
879
880
		if (err < 0)
			goto err_context;
	} while (s->packet_index > 0);
881

882
	/* NOTE: TAG1 matches CIP. This just affects in stream. */
883
884
885
886
	tag = FW_ISO_CONTEXT_MATCH_TAG1;
	if (s->flags & CIP_EMPTY_WITH_TAG0)
		tag |= FW_ISO_CONTEXT_MATCH_TAG0;

887
	s->callbacked = false;
888
	err = fw_iso_context_start(s->context, -1, 0, tag);
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
	if (err < 0)
		goto err_context;

	mutex_unlock(&s->mutex);

	return 0;

err_context:
	fw_iso_context_destroy(s->context);
	s->context = ERR_PTR(-1);
err_buffer:
	iso_packets_buffer_destroy(&s->buffer, s->unit);
err_unlock:
	mutex_unlock(&s->mutex);

	return err;
}
906
EXPORT_SYMBOL(amdtp_stream_start);
907

908
/**
909
910
 * amdtp_stream_pcm_pointer - get the PCM buffer position
 * @s: the AMDTP stream that transports the PCM data
911
912
913
 *
 * Returns the current buffer position, in frames.
 */
914
unsigned long amdtp_stream_pcm_pointer(struct amdtp_stream *s)
915
{
916
	/* this optimization is allowed to be racy */
917
	if (s->pointer_flush && amdtp_stream_running(s))
918
919
920
		fw_iso_context_flush_completions(s->context);
	else
		s->pointer_flush = true;
921
922
923

	return ACCESS_ONCE(s->pcm_buffer_pointer);
}
924
EXPORT_SYMBOL(amdtp_stream_pcm_pointer);
925

926
/**
927
928
 * amdtp_stream_update - update the stream after a bus reset
 * @s: the AMDTP stream
929
 */
930
void amdtp_stream_update(struct amdtp_stream *s)
931
932
933
934
{
	ACCESS_ONCE(s->source_node_id_field) =
		(fw_parent_device(s->unit)->card->node_id & 0x3f) << 24;
}
935
EXPORT_SYMBOL(amdtp_stream_update);
936
937

/**
938
939
 * amdtp_stream_stop - stop sending packets
 * @s: the AMDTP stream to stop
940
941
942
943
 *
 * All PCM and MIDI devices of the stream must be stopped before the stream
 * itself can be stopped.
 */
944
void amdtp_stream_stop(struct amdtp_stream *s)
945
946
947
{
	mutex_lock(&s->mutex);

948
	if (!amdtp_stream_running(s)) {
949
950
951
952
		mutex_unlock(&s->mutex);
		return;
	}

953
	tasklet_kill(&s->period_tasklet);
954
955
956
957
958
	fw_iso_context_stop(s->context);
	fw_iso_context_destroy(s->context);
	s->context = ERR_PTR(-1);
	iso_packets_buffer_destroy(&s->buffer, s->unit);

959
960
	s->callbacked = false;

961
962
	mutex_unlock(&s->mutex);
}
963
EXPORT_SYMBOL(amdtp_stream_stop);
964
965

/**
966
 * amdtp_stream_pcm_abort - abort the running PCM device
967
968
969
970
971
 * @s: the AMDTP stream about to be stopped
 *
 * If the isochronous stream needs to be stopped asynchronously, call this
 * function first to stop the PCM device.
 */
972
void amdtp_stream_pcm_abort(struct amdtp_stream *s)
973
974
975
976
977
978
979
980
981
982
983
{
	struct snd_pcm_substream *pcm;

	pcm = ACCESS_ONCE(s->pcm);
	if (pcm) {
		snd_pcm_stream_lock_irq(pcm);
		if (snd_pcm_running(pcm))
			snd_pcm_stop(pcm, SNDRV_PCM_STATE_XRUN);
		snd_pcm_stream_unlock_irq(pcm);
	}
}
984
EXPORT_SYMBOL(amdtp_stream_pcm_abort);