amdtp.c 29.9 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
#include "amdtp.h"

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

24 25 26 27 28 29
/*
 * Nominally 3125 bytes/second, but the MIDI port's clock might be
 * 1% too slow, and the bus clock 100 ppm too fast.
 */
#define MIDI_BYTES_PER_SECOND	3093

30 31 32 33 34 35
/*
 * Several devices look only at the first eight data blocks.
 * In any case, this is more than enough for the MIDI data rate.
 */
#define MAX_MIDI_RX_BLOCKS	8

36
#define TRANSFER_DELAY_TICKS	0x2e00 /* 479.17 microseconds */
37

38 39
/* isochronous header parameters */
#define ISO_DATA_LENGTH_SHIFT	16
40 41
#define TAG_CIP			1

42
/* common isochronous packet header parameters */
43 44
#define CIP_EOH_SHIFT		31
#define CIP_EOH			(1u << CIP_EOH_SHIFT)
45
#define CIP_EOH_MASK		0x80000000
46 47 48 49 50 51
#define CIP_SID_SHIFT		24
#define CIP_SID_MASK		0x3f000000
#define CIP_DBS_MASK		0x00ff0000
#define CIP_DBS_SHIFT		16
#define CIP_DBC_MASK		0x000000ff
#define CIP_FMT_SHIFT		24
52
#define CIP_FMT_MASK		0x3f000000
53 54
#define CIP_FDF_MASK		0x00ff0000
#define CIP_FDF_SHIFT		16
55 56 57 58 59 60 61
#define CIP_SYT_MASK		0x0000ffff
#define CIP_SYT_NO_INFO		0xffff

/*
 * Audio and Music transfer protocol specific parameters
 * only "Clock-based rate control mode" is supported
 */
62 63
#define CIP_FMT_AM		(0x10 << CIP_FMT_SHIFT)
#define AMDTP_FDF_AM824		(0 << (CIP_FDF_SHIFT + 3))
64
#define AMDTP_FDF_NO_DATA	0xff
65 66 67 68 69

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

70
#define IN_PACKET_HEADER_SIZE	4
71 72
#define OUT_PACKET_HEADER_SIZE	0

73 74
static void pcm_period_tasklet(unsigned long data);

75
/**
76 77
 * amdtp_stream_init - initialize an AMDTP stream structure
 * @s: the AMDTP stream to initialize
78
 * @unit: the target of the stream
79
 * @dir: the direction of stream
80 81
 * @flags: the packet transmission method to use
 */
82
int amdtp_stream_init(struct amdtp_stream *s, struct fw_unit *unit,
83
		      enum amdtp_stream_direction dir, enum cip_flags flags)
84
{
85
	s->unit = unit;
86
	s->direction = dir;
87 88 89
	s->flags = flags;
	s->context = ERR_PTR(-1);
	mutex_init(&s->mutex);
90
	tasklet_init(&s->period_tasklet, pcm_period_tasklet, (unsigned long)s);
91
	s->packet_index = 0;
92

93 94 95 96
	init_waitqueue_head(&s->callback_wait);
	s->callbacked = false;
	s->sync_slave = NULL;

97 98
	return 0;
}
99
EXPORT_SYMBOL(amdtp_stream_init);
100 101

/**
102 103
 * amdtp_stream_destroy - free stream resources
 * @s: the AMDTP stream to destroy
104
 */
105
void amdtp_stream_destroy(struct amdtp_stream *s)
106
{
107
	WARN_ON(amdtp_stream_running(s));
108 109
	mutex_destroy(&s->mutex);
}
110
EXPORT_SYMBOL(amdtp_stream_destroy);
111

112
const unsigned int amdtp_syt_intervals[CIP_SFC_COUNT] = {
113 114 115 116 117 118 119 120 121 122
	[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);

123
const unsigned int amdtp_rate_table[CIP_SFC_COUNT] = {
124 125 126 127 128 129 130 131 132 133
	[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);

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
/**
 * 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
173
	 * preferrable to align period/buffer sizes to current SYT_INTERVAL.
174
	 *
175 176
	 * TODO: These constraints can be improved with proper rules.
	 * Currently apply LCM of SYT_INTERVALs.
177 178 179 180 181 182 183 184 185 186 187 188
	 */
	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);

189
/**
190 191
 * amdtp_stream_set_parameters - set stream parameters
 * @s: the AMDTP stream to configure
192
 * @rate: the sample rate
193 194 195
 * @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)
196
 * @double_pcm_frames: one data block transfers two PCM frames
197
 *
198
 * The parameters must be set before the stream is started, and must not be
199 200
 * changed while the stream is running.
 */
201 202 203
int amdtp_stream_set_parameters(struct amdtp_stream *s,
				unsigned int rate,
				unsigned int pcm_channels,
204 205
				unsigned int midi_ports,
				bool double_pcm_frames)
206
{
207
	unsigned int i, sfc, midi_channels;
208

209 210
	midi_channels = DIV_ROUND_UP(midi_ports, 8);

211 212
	if (WARN_ON(amdtp_stream_running(s)) |
	    WARN_ON(pcm_channels > AMDTP_MAX_CHANNELS_FOR_PCM) |
213
	    WARN_ON(midi_channels > AMDTP_MAX_CHANNELS_FOR_MIDI))
214
		return -EINVAL;
215

216
	for (sfc = 0; sfc < ARRAY_SIZE(amdtp_rate_table); ++sfc) {
217
		if (amdtp_rate_table[sfc] == rate)
218 219 220 221
			break;
	}
	if (sfc == ARRAY_SIZE(amdtp_rate_table))
		return -EINVAL;
222

223
	s->pcm_channels = pcm_channels;
224
	s->sfc = sfc;
225
	s->data_block_quadlets = s->pcm_channels + midi_channels;
226 227 228
	s->midi_ports = midi_ports;

	s->syt_interval = amdtp_syt_intervals[sfc];
229 230 231 232 233 234

	/* 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;
235 236 237 238 239

	/* 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;
240 241 242 243 244 245 246 247

	/*
	 * We do not know the actual MIDI FIFO size of most devices.  Just
	 * assume two bytes, i.e., one byte can be received over the bus while
	 * the previous one is transmitted over MIDI.
	 * (The value here is adjusted for midi_ratelimit_per_packet().)
	 */
	s->midi_fifo_limit = rate - MIDI_BYTES_PER_SECOND * s->syt_interval + 1;
248 249

	return 0;
250
}
251
EXPORT_SYMBOL(amdtp_stream_set_parameters);
252 253

/**
254 255
 * amdtp_stream_get_max_payload - get the stream's packet size
 * @s: the AMDTP stream
256 257
 *
 * This function must not be called before the stream has been configured
258
 * with amdtp_stream_set_parameters().
259
 */
260
unsigned int amdtp_stream_get_max_payload(struct amdtp_stream *s)
261
{
262 263 264 265 266 267
	unsigned int multiplier = 1;

	if (s->flags & CIP_JUMBO_PAYLOAD)
		multiplier = 5;

	return 8 + s->syt_interval * s->data_block_quadlets * 4 * multiplier;
268
}
269
EXPORT_SYMBOL(amdtp_stream_get_max_payload);
270

271 272 273 274 275 276 277 278 279
static void write_pcm_s16(struct amdtp_stream *s,
			  struct snd_pcm_substream *pcm,
			  __be32 *buffer, unsigned int frames);
static void write_pcm_s32(struct amdtp_stream *s,
			  struct snd_pcm_substream *pcm,
			  __be32 *buffer, unsigned int frames);
static void read_pcm_s32(struct amdtp_stream *s,
			 struct snd_pcm_substream *pcm,
			 __be32 *buffer, unsigned int frames);
280 281

/**
282 283
 * amdtp_stream_set_pcm_format - set the PCM format
 * @s: the AMDTP stream to configure
284 285
 * @format: the format of the ALSA PCM device
 *
286
 * The sample format must be set after the other parameters (rate/PCM channels/
287 288
 * MIDI) and before the stream is started, and must not be changed while the
 * stream is running.
289
 */
290 291
void amdtp_stream_set_pcm_format(struct amdtp_stream *s,
				 snd_pcm_format_t format)
292
{
293
	if (WARN_ON(amdtp_stream_pcm_running(s)))
294 295 296 297 298 299 300
		return;

	switch (format) {
	default:
		WARN_ON(1);
		/* fall through */
	case SNDRV_PCM_FORMAT_S16:
301
		if (s->direction == AMDTP_OUT_STREAM) {
302
			s->transfer_samples = write_pcm_s16;
303 304 305 306
			break;
		}
		WARN_ON(1);
		/* fall through */
307
	case SNDRV_PCM_FORMAT_S32:
308
		if (s->direction == AMDTP_OUT_STREAM)
309
			s->transfer_samples = write_pcm_s32;
310
		else
311
			s->transfer_samples = read_pcm_s32;
312 313 314
		break;
	}
}
315
EXPORT_SYMBOL(amdtp_stream_set_pcm_format);
316

317
/**
318 319
 * amdtp_stream_pcm_prepare - prepare PCM device for running
 * @s: the AMDTP stream
320 321 322
 *
 * This function should be called from the PCM device's .prepare callback.
 */
323
void amdtp_stream_pcm_prepare(struct amdtp_stream *s)
324 325 326 327
{
	tasklet_kill(&s->period_tasklet);
	s->pcm_buffer_pointer = 0;
	s->pcm_period_pointer = 0;
328
	s->pointer_flush = true;
329
}
330
EXPORT_SYMBOL(amdtp_stream_pcm_prepare);
331

332 333
static unsigned int calculate_data_blocks(struct amdtp_stream *s,
					  unsigned int syt)
334 335 336
{
	unsigned int phase, data_blocks;

337 338 339 340 341 342 343 344
	/* Blocking mode. */
	if (s->flags & CIP_BLOCKING) {
		/* This module generate empty packet for 'no data'. */
		if (syt == CIP_SYT_NO_INFO)
			data_blocks = 0;
		else
			data_blocks = s->syt_interval;
	/* Non-blocking mode. */
345
	} else {
346 347 348 349 350
		if (!cip_sfc_is_base_44100(s->sfc)) {
			/* Sample_rate / 8000 is an integer, and precomputed. */
			data_blocks = s->data_block_state;
		} else {
			phase = s->data_block_state;
351 352 353 354 355 356 357 358 359

		/*
		 * 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).
		 */
360 361 362 363 364 365 366 367 368 369 370
			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;
		}
371 372 373 374 375
	}

	return data_blocks;
}

376
static unsigned int calculate_syt(struct amdtp_stream *s,
377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
				  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;

408
	if (syt_offset < TICKS_PER_CYCLE) {
409
		syt_offset += s->transfer_delay;
410 411
		syt = (cycle + syt_offset / TICKS_PER_CYCLE) << 12;
		syt += syt_offset % TICKS_PER_CYCLE;
412

413
		return syt & CIP_SYT_MASK;
414
	} else {
415
		return CIP_SYT_NO_INFO;
416
	}
417 418
}

419 420 421
static void write_pcm_s32(struct amdtp_stream *s,
			  struct snd_pcm_substream *pcm,
			  __be32 *buffer, unsigned int frames)
422 423
{
	struct snd_pcm_runtime *runtime = pcm->runtime;
424
	unsigned int channels, remaining_frames, i, c;
425 426 427 428
	const u32 *src;

	channels = s->pcm_channels;
	src = (void *)runtime->dma_area +
429
			frames_to_bytes(runtime, s->pcm_buffer_pointer);
430 431 432 433
	remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;

	for (i = 0; i < frames; ++i) {
		for (c = 0; c < channels; ++c) {
434 435
			buffer[s->pcm_positions[c]] =
					cpu_to_be32((*src >> 8) | 0x40000000);
436 437
			src++;
		}
438
		buffer += s->data_block_quadlets;
439 440 441 442 443
		if (--remaining_frames == 0)
			src = (void *)runtime->dma_area;
	}
}

444 445 446
static void write_pcm_s16(struct amdtp_stream *s,
			  struct snd_pcm_substream *pcm,
			  __be32 *buffer, unsigned int frames)
447 448
{
	struct snd_pcm_runtime *runtime = pcm->runtime;
449
	unsigned int channels, remaining_frames, i, c;
450 451 452 453
	const u16 *src;

	channels = s->pcm_channels;
	src = (void *)runtime->dma_area +
454
			frames_to_bytes(runtime, s->pcm_buffer_pointer);
455 456 457 458
	remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;

	for (i = 0; i < frames; ++i) {
		for (c = 0; c < channels; ++c) {
459
			buffer[s->pcm_positions[c]] =
460
					cpu_to_be32((*src << 8) | 0x42000000);
461 462
			src++;
		}
463
		buffer += s->data_block_quadlets;
464 465 466 467 468
		if (--remaining_frames == 0)
			src = (void *)runtime->dma_area;
	}
}

469 470 471
static void read_pcm_s32(struct amdtp_stream *s,
			 struct snd_pcm_substream *pcm,
			 __be32 *buffer, unsigned int frames)
472 473 474 475 476 477 478 479 480 481 482 483
{
	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) {
484
			*dst = be32_to_cpu(buffer[s->pcm_positions[c]]) << 8;
485 486 487 488 489 490 491 492
			dst++;
		}
		buffer += s->data_block_quadlets;
		if (--remaining_frames == 0)
			dst = (void *)runtime->dma_area;
	}
}

493 494
static void write_pcm_silence(struct amdtp_stream *s,
			      __be32 *buffer, unsigned int frames)
495 496 497 498 499
{
	unsigned int i, c;

	for (i = 0; i < frames; ++i) {
		for (c = 0; c < s->pcm_channels; ++c)
500
			buffer[s->pcm_positions[c]] = cpu_to_be32(0x40000000);
501 502 503 504
		buffer += s->data_block_quadlets;
	}
}

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
/*
 * To avoid sending MIDI bytes at too high a rate, assume that the receiving
 * device has a FIFO, and track how much it is filled.  This values increases
 * by one whenever we send one byte in a packet, but the FIFO empties at
 * a constant rate independent of our packet rate.  One packet has syt_interval
 * samples, so the number of bytes that empty out of the FIFO, per packet(!),
 * is MIDI_BYTES_PER_SECOND * syt_interval / sample_rate.  To avoid storing
 * fractional values, the values in midi_fifo_used[] are measured in bytes
 * multiplied by the sample rate.
 */
static bool midi_ratelimit_per_packet(struct amdtp_stream *s, unsigned int port)
{
	int used;

	used = s->midi_fifo_used[port];
	if (used == 0) /* common shortcut */
		return true;

	used -= MIDI_BYTES_PER_SECOND * s->syt_interval;
	used = max(used, 0);
	s->midi_fifo_used[port] = used;

	return used < s->midi_fifo_limit;
}

static void midi_rate_use_one_byte(struct amdtp_stream *s, unsigned int port)
{
	s->midi_fifo_used[port] += amdtp_rate_table[s->sfc];
}

535 536
static void write_midi_messages(struct amdtp_stream *s,
				__be32 *buffer, unsigned int frames)
537
{
538 539 540 541
	unsigned int f, port;
	u8 *b;

	for (f = 0; f < frames; f++) {
542
		b = (u8 *)&buffer[s->midi_position];
543 544

		port = (s->data_block_counter + f) % 8;
545 546 547 548 549
		if (f < MAX_MIDI_RX_BLOCKS &&
		    midi_ratelimit_per_packet(s, port) &&
		    s->midi[port] != NULL &&
		    snd_rawmidi_transmit(s->midi[port], &b[1], 1) == 1) {
			midi_rate_use_one_byte(s, port);
550
			b[0] = 0x81;
551 552 553 554 555 556
		} else {
			b[0] = 0x80;
			b[1] = 0;
		}
		b[2] = 0;
		b[3] = 0;
557 558 559 560 561

		buffer += s->data_block_quadlets;
	}
}

562 563
static void read_midi_messages(struct amdtp_stream *s,
			       __be32 *buffer, unsigned int frames)
564 565 566 567 568 569 570
{
	unsigned int f, port;
	int len;
	u8 *b;

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

573 574 575 576 577 578
		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;
	}
579 580
}

581 582 583
static void update_pcm_pointers(struct amdtp_stream *s,
				struct snd_pcm_substream *pcm,
				unsigned int frames)
584 585 586 587 588 589 590 591 592 593
{
	unsigned int ptr;

	/*
	 * In IEC 61883-6, one data block represents one event. In ALSA, one
	 * event equals to one PCM frame. But Dice has a quirk to transfer
	 * two PCM frames in one data block.
	 */
	if (s->double_pcm_frames)
		frames *= 2;
594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621

	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};
622 623 624 625
	int err = 0;

	if (IS_ERR(s->context))
		goto end;
626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651

	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);
}

652 653 654 655 656 657
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);
}

658 659
static int handle_out_packet(struct amdtp_stream *s, unsigned int data_blocks,
			     unsigned int syt)
660 661
{
	__be32 *buffer;
662
	unsigned int payload_length;
663 664
	struct snd_pcm_substream *pcm;

665
	buffer = s->buffer.packets[s->packet_index].buffer;
666
	buffer[0] = cpu_to_be32(ACCESS_ONCE(s->source_node_id_field) |
667
				(s->data_block_quadlets << CIP_DBS_SHIFT) |
668 669
				s->data_block_counter);
	buffer[1] = cpu_to_be32(CIP_EOH | CIP_FMT_AM | AMDTP_FDF_AM824 |
670
				(s->sfc << CIP_FDF_SHIFT) | syt);
671 672 673 674 675 676
	buffer += 2;

	pcm = ACCESS_ONCE(s->pcm);
	if (pcm)
		s->transfer_samples(s, pcm, buffer, data_blocks);
	else
677
		write_pcm_silence(s, buffer, data_blocks);
678
	if (s->midi_ports)
679
		write_midi_messages(s, buffer, data_blocks);
680 681 682

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

683
	payload_length = 8 + data_blocks * 4 * s->data_block_quadlets;
684 685
	if (queue_out_packet(s, payload_length, false) < 0)
		return -EIO;
686

687
	if (pcm)
688
		update_pcm_pointers(s, pcm, data_blocks);
689 690 691

	/* No need to return the number of handled data blocks. */
	return 0;
692 693
}

694
static int handle_in_packet(struct amdtp_stream *s,
695 696
			    unsigned int payload_quadlets, __be32 *buffer,
			    unsigned int *data_blocks)
697 698
{
	u32 cip_header[2];
699
	unsigned int data_block_quadlets, data_block_counter, dbc_interval;
700
	struct snd_pcm_substream *pcm = NULL;
701
	bool lost;
702 703 704 705 706 707

	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'.
708
	 * For convenience, also check FMT field is AM824 or not.
709 710 711 712 713 714 715
	 */
	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]);
716
		*data_blocks = 0;
717 718 719 720 721 722
		goto end;
	}

	/* Calculate data blocks */
	if (payload_quadlets < 3 ||
	    ((cip_header[1] & CIP_FDF_MASK) ==
723
				(AMDTP_FDF_NO_DATA << CIP_FDF_SHIFT))) {
724
		*data_blocks = 0;
725 726
	} else {
		data_block_quadlets =
727
			(cip_header[0] & CIP_DBS_MASK) >> CIP_DBS_SHIFT;
728 729
		/* avoid division by zero */
		if (data_block_quadlets == 0) {
730
			dev_err(&s->unit->device,
731 732
				"Detect invalid value in dbs field: %08X\n",
				cip_header[0]);
733
			return -EPROTO;
734
		}
735 736
		if (s->flags & CIP_WRONG_DBS)
			data_block_quadlets = s->data_block_quadlets;
737

738
		*data_blocks = (payload_quadlets - 2) / data_block_quadlets;
739 740 741
	}

	/* Check data block counter continuity */
742
	data_block_counter = cip_header[0] & CIP_DBC_MASK;
743
	if (*data_blocks == 0 && (s->flags & CIP_EMPTY_HAS_WRONG_DBC) &&
744 745 746
	    s->data_block_counter != UINT_MAX)
		data_block_counter = s->data_block_counter;

747 748 749
	if (((s->flags & CIP_SKIP_DBC_ZERO_CHECK) &&
	     data_block_counter == s->tx_first_dbc) ||
	    s->data_block_counter == UINT_MAX) {
750 751
		lost = false;
	} else if (!(s->flags & CIP_DBC_IS_END_EVENT)) {
752
		lost = data_block_counter != s->data_block_counter;
753
	} else {
754
		if ((*data_blocks > 0) && (s->tx_dbc_interval > 0))
755 756
			dbc_interval = s->tx_dbc_interval;
		else
757
			dbc_interval = *data_blocks;
758

759
		lost = data_block_counter !=
760 761
		       ((s->data_block_counter + dbc_interval) & 0xff);
	}
762 763

	if (lost) {
764 765 766
		dev_err(&s->unit->device,
			"Detect discontinuity of CIP: %02X %02X\n",
			s->data_block_counter, data_block_counter);
767
		return -EIO;
768 769
	}

770
	if (*data_blocks > 0) {
771 772 773 774
		buffer += 2;

		pcm = ACCESS_ONCE(s->pcm);
		if (pcm)
775
			s->transfer_samples(s, pcm, buffer, *data_blocks);
776 777

		if (s->midi_ports)
778
			read_midi_messages(s, buffer, *data_blocks);
779 780
	}

781 782 783 784
	if (s->flags & CIP_DBC_IS_END_EVENT)
		s->data_block_counter = data_block_counter;
	else
		s->data_block_counter =
785
				(data_block_counter + *data_blocks) & 0xff;
786 787
end:
	if (queue_in_packet(s) < 0)
788
		return -EIO;
789 790

	if (pcm)
791
		update_pcm_pointers(s, pcm, *data_blocks);
792

793
	return 0;
794 795
}

796 797 798
static void out_stream_callback(struct fw_iso_context *context, u32 cycle,
				size_t header_length, void *header,
				void *private_data)
799
{
800
	struct amdtp_stream *s = private_data;
801
	unsigned int i, syt, packets = header_length / 4;
802
	unsigned int data_blocks;
803

804 805 806
	if (s->packet_index < 0)
		return;

807 808 809 810 811 812 813
	/*
	 * 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;

814 815
	for (i = 0; i < packets; ++i) {
		syt = calculate_syt(s, ++cycle);
816 817
		data_blocks = calculate_data_blocks(s, syt);

818 819 820 821 822
		if (handle_out_packet(s, data_blocks, syt) < 0) {
			s->packet_index = -1;
			amdtp_stream_pcm_abort(s);
			return;
		}
823
	}
824

825
	fw_iso_context_queue_flush(s->context);
826 827
}

828 829 830 831 832
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;
833 834
	unsigned int p, syt, packets;
	unsigned int payload_quadlets, max_payload_quadlets;
835
	unsigned int data_blocks;
836 837
	__be32 *buffer, *headers = header;

838 839 840
	if (s->packet_index < 0)
		return;

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

844 845 846
	/* For buffer-over-run prevention. */
	max_payload_quadlets = amdtp_stream_get_max_payload(s) / 4;

847 848 849 850 851 852
	for (p = 0; p < packets; p++) {
		buffer = s->buffer.packets[s->packet_index].buffer;

		/* The number of quadlets in this packet */
		payload_quadlets =
			(be32_to_cpu(headers[p]) >> ISO_DATA_LENGTH_SHIFT) / 4;
853 854 855 856 857 858 859 860
		if (payload_quadlets > max_payload_quadlets) {
			dev_err(&s->unit->device,
				"Detect jumbo payload: %02x %02x\n",
				payload_quadlets, max_payload_quadlets);
			s->packet_index = -1;
			break;
		}

861 862
		if (handle_in_packet(s, payload_quadlets, buffer,
							&data_blocks) < 0) {
863 864 865 866 867 868 869
			s->packet_index = -1;
			break;
		}

		/* Process sync slave stream */
		if (s->sync_slave && s->sync_slave->callbacked) {
			syt = be32_to_cpu(buffer[1]) & CIP_SYT_MASK;
870 871 872 873 874
			if (handle_out_packet(s->sync_slave,
					      data_blocks, syt) < 0) {
				s->packet_index = -1;
				break;
			}
875
		}
876 877
	}

878 879
	/* Queueing error or detecting discontinuity */
	if (s->packet_index < 0) {
880 881
		amdtp_stream_pcm_abort(s);

882 883 884 885 886 887 888 889 890 891 892 893
		/* 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);

894 895 896
	fw_iso_context_queue_flush(s->context);
}

897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920
/* 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;
921
	else if (s->flags & CIP_SYNC_TO_DEVICE)
922 923 924 925 926 927 928
		context->callback.sc = slave_stream_callback;
	else
		context->callback.sc = out_stream_callback;

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

929
/**
930 931
 * amdtp_stream_start - start transferring packets
 * @s: the AMDTP stream to start
932 933 934 935
 * @channel: the isochronous channel on the bus
 * @speed: firewire speed code
 *
 * The stream cannot be started until it has been configured with
936 937
 * amdtp_stream_set_parameters() and it must be started before any PCM or MIDI
 * device can be started.
938
 */
939
int amdtp_stream_start(struct amdtp_stream *s, int channel, int speed)
940 941 942 943 944 945 946 947 948 949 950 951 952
{
	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 },
	};
953 954
	unsigned int header_size;
	enum dma_data_direction dir;
955
	int type, tag, err;
956 957 958

	mutex_lock(&s->mutex);

959
	if (WARN_ON(amdtp_stream_running(s) ||
960
		    (s->data_block_quadlets < 1))) {
961 962 963 964
		err = -EBADFD;
		goto err_unlock;
	}

965 966 967 968 969
	if (s->direction == AMDTP_IN_STREAM &&
	    s->flags & CIP_SKIP_INIT_DBC_CHECK)
		s->data_block_counter = UINT_MAX;
	else
		s->data_block_counter = 0;
970 971 972 973
	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;

974 975 976 977 978 979 980 981 982 983
	/* 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;
	}
984
	err = iso_packets_buffer_init(&s->buffer, s->unit, QUEUE_LENGTH,
985
				      amdtp_stream_get_max_payload(s), dir);
986 987 988 989
	if (err < 0)
		goto err_unlock;

	s->context = fw_iso_context_create(fw_parent_device(s->unit)->card,
990
					   type, channel, speed, header_size,
991
					   amdtp_stream_first_callback, s);
992 993 994 995
	if (IS_ERR(s->context)) {
		err = PTR_ERR(s->context);
		if (err == -EBUSY)
			dev_err(&s->unit->device,
996
				"no free stream on this controller\n");
997 998 999
		goto err_buffer;
	}

1000
	amdtp_stream_update(s);
1001

1002
	s->packet_index = 0;
1003
	do {
1004 1005 1006 1007
		if (s->direction == AMDTP_IN_STREAM)
			err = queue_in_packet(s);
		else
			err = queue_out_packet(s, 0, true);
1008 1009 1010
		if (err < 0)
			goto err_context;
	} while (s->packet_index > 0);
1011

1012
	/* NOTE: TAG1 matches CIP. This just affects in stream. */
1013 1014 1015 1016
	tag = FW_ISO_CONTEXT_MATCH_TAG1;
	if (s->flags & CIP_EMPTY_WITH_TAG0)
		tag |= FW_ISO_CONTEXT_MATCH_TAG0;

1017
	s->callbacked = false;
1018
	err = fw_iso_context_start(s->context, -1, 0, tag);
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
	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;
}
1036
EXPORT_SYMBOL(amdtp_stream_start);
1037

1038
/**
1039 1040
 * amdtp_stream_pcm_pointer - get the PCM buffer position
 * @s: the AMDTP stream that transports the PCM data
1041 1042 1043
 *
 * Returns the current buffer position, in frames.
 */
1044
unsigned long amdtp_stream_pcm_pointer(struct amdtp_stream *s)
1045
{
1046
	/* this optimization is allowed to be racy */
1047
	if (s->pointer_flush && amdtp_stream_running(s))
1048 1049 1050
		fw_iso_context_flush_completions(s->context);
	else
		s->pointer_flush = true;
1051 1052 1053

	return ACCESS_ONCE(s->pcm_buffer_pointer);
}
1054
EXPORT_SYMBOL(amdtp_stream_pcm_pointer);
1055

1056
/**
1057 1058
 * amdtp_stream_update - update the stream after a bus reset
 * @s: the AMDTP stream
1059
 */
1060
void amdtp_stream_update(struct amdtp_stream *s)
1061
{
1062
	/* Precomputing. */
1063
	ACCESS_ONCE(s->source_node_id_field) =
1064 1065
		(fw_parent_device(s->unit)->card->node_id << CIP_SID_SHIFT) &
								CIP_SID_MASK;
1066
}
1067
EXPORT_SYMBOL(amdtp_stream_update);
1068 1069

/**
1070 1071
 * amdtp_stream_stop - stop sending packets
 * @s: the AMDTP stream to stop
1072 1073 1074 1075
 *
 * All PCM and MIDI devices of the stream must be stopped before the stream
 * itself can be stopped.
 */
1076
void amdtp_stream_stop(struct amdtp_stream *s)
1077 1078 1079
{
	mutex_lock(&s->mutex);

1080
	if (!amdtp_stream_running(s)) {
1081 1082 1083 1084
		mutex_unlock(&s->mutex);
		return;
	}

1085
	tasklet_kill(&s->period_tasklet);
1086 1087 1088 1089 1090
	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);

1091 1092
	s->callbacked = false;

1093 1094
	mutex_unlock(&s->mutex);
}
1095
EXPORT_SYMBOL(amdtp_stream_stop);
1096 1097

/**
1098
 * amdtp_stream_pcm_abort - abort the running PCM device
1099 1100 1101 1102 1103
 * @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.
 */
1104
void amdtp_stream_pcm_abort(struct amdtp_stream *s)
1105 1106 1107 1108
{
	struct snd_pcm_substream *pcm;

	pcm = ACCESS_ONCE(s->pcm);
1109 1110
	if (pcm)
		snd_pcm_stop_xrun(pcm);
1111
}
1112
EXPORT_SYMBOL(amdtp_stream_pcm_abort);