amdtp-stream.c 23.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/*
 * 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>
#include <sound/pcm.h>
15
#include <sound/pcm_params.h>
16
#include "amdtp-stream.h"
17 18 19 20 21

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

22 23 24 25
/* Always support Linux tracing subsystem. */
#define CREATE_TRACE_POINTS
#include "amdtp-stream-trace.h"

26
#define TRANSFER_DELAY_TICKS	0x2e00 /* 479.17 microseconds */
27

28 29
/* isochronous header parameters */
#define ISO_DATA_LENGTH_SHIFT	16
30 31
#define TAG_CIP			1

32
/* common isochronous packet header parameters */
33 34
#define CIP_EOH_SHIFT		31
#define CIP_EOH			(1u << CIP_EOH_SHIFT)
35
#define CIP_EOH_MASK		0x80000000
36 37 38 39 40 41
#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
42
#define CIP_FMT_MASK		0x3f000000
43 44
#define CIP_FDF_MASK		0x00ff0000
#define CIP_FDF_SHIFT		16
45 46 47
#define CIP_SYT_MASK		0x0000ffff
#define CIP_SYT_NO_INFO		0xffff

48
/* Audio and Music transfer protocol specific parameters */
49
#define CIP_FMT_AM		0x10
50
#define AMDTP_FDF_NO_DATA	0xff
51 52 53 54 55

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

56
#define IN_PACKET_HEADER_SIZE	4
57 58
#define OUT_PACKET_HEADER_SIZE	0

59 60
static void pcm_period_tasklet(unsigned long data);

61
/**
62 63
 * amdtp_stream_init - initialize an AMDTP stream structure
 * @s: the AMDTP stream to initialize
64
 * @unit: the target of the stream
65
 * @dir: the direction of stream
66
 * @flags: the packet transmission method to use
67
 * @fmt: the value of fmt field in CIP header
68 69
 * @process_data_blocks: callback handler to process data blocks
 * @protocol_size: the size to allocate newly for protocol
70
 */
71
int amdtp_stream_init(struct amdtp_stream *s, struct fw_unit *unit,
72
		      enum amdtp_stream_direction dir, enum cip_flags flags,
73 74 75
		      unsigned int fmt,
		      amdtp_stream_process_data_blocks_t process_data_blocks,
		      unsigned int protocol_size)
76
{
77 78 79 80 81 82 83
	if (process_data_blocks == NULL)
		return -EINVAL;

	s->protocol = kzalloc(protocol_size, GFP_KERNEL);
	if (!s->protocol)
		return -ENOMEM;

84
	s->unit = unit;
85
	s->direction = dir;
86 87 88
	s->flags = flags;
	s->context = ERR_PTR(-1);
	mutex_init(&s->mutex);
89
	tasklet_init(&s->period_tasklet, pcm_period_tasklet, (unsigned long)s);
90
	s->packet_index = 0;
91

92 93 94
	init_waitqueue_head(&s->callback_wait);
	s->callbacked = false;

95
	s->fmt = fmt;
96
	s->process_data_blocks = process_data_blocks;
97

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

/**
103 104
 * amdtp_stream_destroy - free stream resources
 * @s: the AMDTP stream to destroy
105
 */
106
void amdtp_stream_destroy(struct amdtp_stream *s)
107
{
108 109 110 111
	/* Not initialized. */
	if (s->protocol == NULL)
		return;

112
	WARN_ON(amdtp_stream_running(s));
113
	kfree(s->protocol);
114 115
	mutex_destroy(&s->mutex);
}
116
EXPORT_SYMBOL(amdtp_stream_destroy);
117

118
const unsigned int amdtp_syt_intervals[CIP_SFC_COUNT] = {
119 120 121 122 123 124 125 126 127 128
	[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);

129
const unsigned int amdtp_rate_table[CIP_SFC_COUNT] = {
130 131 132 133 134 135 136 137 138 139
	[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);

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;

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

190
/**
191 192
 * amdtp_stream_set_parameters - set stream parameters
 * @s: the AMDTP stream to configure
193
 * @rate: the sample rate
194
 * @data_block_quadlets: the size of a data block in quadlet unit
195
 *
196
 * The parameters must be set before the stream is started, and must not be
197 198
 * changed while the stream is running.
 */
199 200
int amdtp_stream_set_parameters(struct amdtp_stream *s, unsigned int rate,
				unsigned int data_block_quadlets)
201
{
202
	unsigned int sfc;
203

204
	for (sfc = 0; sfc < ARRAY_SIZE(amdtp_rate_table); ++sfc) {
205
		if (amdtp_rate_table[sfc] == rate)
206 207 208 209
			break;
	}
	if (sfc == ARRAY_SIZE(amdtp_rate_table))
		return -EINVAL;
210 211

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

	/* 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;
220

221
	return 0;
222
}
223
EXPORT_SYMBOL(amdtp_stream_set_parameters);
224 225

/**
226 227
 * amdtp_stream_get_max_payload - get the stream's packet size
 * @s: the AMDTP stream
228 229
 *
 * This function must not be called before the stream has been configured
230
 * with amdtp_stream_set_parameters().
231
 */
232
unsigned int amdtp_stream_get_max_payload(struct amdtp_stream *s)
233
{
234 235 236 237 238 239
	unsigned int multiplier = 1;

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

	return 8 + s->syt_interval * s->data_block_quadlets * 4 * multiplier;
240
}
241
EXPORT_SYMBOL(amdtp_stream_get_max_payload);
242

243
/**
244 245
 * amdtp_stream_pcm_prepare - prepare PCM device for running
 * @s: the AMDTP stream
246 247 248
 *
 * This function should be called from the PCM device's .prepare callback.
 */
249
void amdtp_stream_pcm_prepare(struct amdtp_stream *s)
250 251 252 253
{
	tasklet_kill(&s->period_tasklet);
	s->pcm_buffer_pointer = 0;
	s->pcm_period_pointer = 0;
254
	s->pointer_flush = true;
255
}
256
EXPORT_SYMBOL(amdtp_stream_pcm_prepare);
257

258 259
static unsigned int calculate_data_blocks(struct amdtp_stream *s,
					  unsigned int syt)
260 261 262
{
	unsigned int phase, data_blocks;

263 264 265 266 267 268 269 270
	/* 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. */
271
	} else {
272 273 274 275 276
		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;
277 278 279 280 281 282 283 284 285

		/*
		 * 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).
		 */
286 287 288 289 290 291 292 293 294 295 296
			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;
		}
297 298 299 300 301
	}

	return data_blocks;
}

302
static unsigned int calculate_syt(struct amdtp_stream *s,
303 304 305 306 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
				  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;

334
	if (syt_offset < TICKS_PER_CYCLE) {
335
		syt_offset += s->transfer_delay;
336 337
		syt = (cycle + syt_offset / TICKS_PER_CYCLE) << 12;
		syt += syt_offset % TICKS_PER_CYCLE;
338

339
		return syt & CIP_SYT_MASK;
340
	} else {
341
		return CIP_SYT_NO_INFO;
342
	}
343 344
}

345 346 347
static void update_pcm_pointers(struct amdtp_stream *s,
				struct snd_pcm_substream *pcm,
				unsigned int frames)
348 349 350
{
	unsigned int ptr;

351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377
	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};
378 379 380 381
	int err = 0;

	if (IS_ERR(s->context))
		goto end;
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

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

408 409 410 411 412 413
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);
}

414
static int handle_out_packet(struct amdtp_stream *s, unsigned int data_blocks,
415
			     unsigned int cycle, unsigned int syt)
416 417
{
	__be32 *buffer;
418
	unsigned int payload_length;
419
	unsigned int pcm_frames;
420 421
	struct snd_pcm_substream *pcm;

422
	buffer = s->buffer.packets[s->packet_index].buffer;
423
	pcm_frames = s->process_data_blocks(s, buffer + 2, data_blocks, &syt);
424

425
	buffer[0] = cpu_to_be32(ACCESS_ONCE(s->source_node_id_field) |
426
				(s->data_block_quadlets << CIP_DBS_SHIFT) |
427
				s->data_block_counter);
428 429 430 431
	buffer[1] = cpu_to_be32(CIP_EOH |
				((s->fmt << CIP_FMT_SHIFT) & CIP_FMT_MASK) |
				((s->fdf << CIP_FDF_SHIFT) & CIP_FDF_MASK) |
				(syt & CIP_SYT_MASK));
432 433

	s->data_block_counter = (s->data_block_counter + data_blocks) & 0xff;
434
	payload_length = 8 + data_blocks * 4 * s->data_block_quadlets;
435 436 437

	trace_out_packet(s, cycle, buffer, payload_length);

438 439
	if (queue_out_packet(s, payload_length, false) < 0)
		return -EIO;
440

441 442 443
	pcm = ACCESS_ONCE(s->pcm);
	if (pcm && pcm_frames > 0)
		update_pcm_pointers(s, pcm, pcm_frames);
444 445 446

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

449
static int handle_in_packet(struct amdtp_stream *s,
450
			    unsigned int payload_quadlets, __be32 *buffer,
451 452
			    unsigned int *data_blocks, unsigned int cycle,
			    unsigned int syt)
453 454
{
	u32 cip_header[2];
455
	unsigned int fmt, fdf;
456
	unsigned int data_block_quadlets, data_block_counter, dbc_interval;
457 458
	struct snd_pcm_substream *pcm;
	unsigned int pcm_frames;
459
	bool lost;
460 461 462 463

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

464 465
	trace_in_packet(s, cycle, cip_header, payload_quadlets);

466 467
	/*
	 * This module supports 'Two-quadlet CIP header with SYT field'.
468
	 * For convenience, also check FMT field is AM824 or not.
469 470
	 */
	if (((cip_header[0] & CIP_EOH_MASK) == CIP_EOH) ||
471
	    ((cip_header[1] & CIP_EOH_MASK) != CIP_EOH)) {
472 473 474
		dev_info_ratelimited(&s->unit->device,
				"Invalid CIP header for AMDTP: %08X:%08X\n",
				cip_header[0], cip_header[1]);
475
		*data_blocks = 0;
476
		pcm_frames = 0;
477 478 479
		goto end;
	}

480 481 482
	/* Check valid protocol or not. */
	fmt = (cip_header[1] & CIP_FMT_MASK) >> CIP_FMT_SHIFT;
	if (fmt != s->fmt) {
483 484 485 486 487 488
		dev_info_ratelimited(&s->unit->device,
				     "Detect unexpected protocol: %08x %08x\n",
				     cip_header[0], cip_header[1]);
		*data_blocks = 0;
		pcm_frames = 0;
		goto end;
489 490
	}

491
	/* Calculate data blocks */
492
	fdf = (cip_header[1] & CIP_FDF_MASK) >> CIP_FDF_SHIFT;
493
	if (payload_quadlets < 3 ||
494
	    (fmt == CIP_FMT_AM && fdf == AMDTP_FDF_NO_DATA)) {
495
		*data_blocks = 0;
496 497
	} else {
		data_block_quadlets =
498
			(cip_header[0] & CIP_DBS_MASK) >> CIP_DBS_SHIFT;
499 500
		/* avoid division by zero */
		if (data_block_quadlets == 0) {
501
			dev_err(&s->unit->device,
502 503
				"Detect invalid value in dbs field: %08X\n",
				cip_header[0]);
504
			return -EPROTO;
505
		}
506 507
		if (s->flags & CIP_WRONG_DBS)
			data_block_quadlets = s->data_block_quadlets;
508

509
		*data_blocks = (payload_quadlets - 2) / data_block_quadlets;
510 511 512
	}

	/* Check data block counter continuity */
513
	data_block_counter = cip_header[0] & CIP_DBC_MASK;
514
	if (*data_blocks == 0 && (s->flags & CIP_EMPTY_HAS_WRONG_DBC) &&
515 516 517
	    s->data_block_counter != UINT_MAX)
		data_block_counter = s->data_block_counter;

518 519 520
	if (((s->flags & CIP_SKIP_DBC_ZERO_CHECK) &&
	     data_block_counter == s->tx_first_dbc) ||
	    s->data_block_counter == UINT_MAX) {
521 522
		lost = false;
	} else if (!(s->flags & CIP_DBC_IS_END_EVENT)) {
523
		lost = data_block_counter != s->data_block_counter;
524
	} else {
525
		if ((*data_blocks > 0) && (s->tx_dbc_interval > 0))
526 527
			dbc_interval = s->tx_dbc_interval;
		else
528
			dbc_interval = *data_blocks;
529

530
		lost = data_block_counter !=
531 532
		       ((s->data_block_counter + dbc_interval) & 0xff);
	}
533 534

	if (lost) {
535 536 537
		dev_err(&s->unit->device,
			"Detect discontinuity of CIP: %02X %02X\n",
			s->data_block_counter, data_block_counter);
538
		return -EIO;
539 540
	}

541
	pcm_frames = s->process_data_blocks(s, buffer + 2, *data_blocks, &syt);
542

543 544 545 546
	if (s->flags & CIP_DBC_IS_END_EVENT)
		s->data_block_counter = data_block_counter;
	else
		s->data_block_counter =
547
				(data_block_counter + *data_blocks) & 0xff;
548 549
end:
	if (queue_in_packet(s) < 0)
550
		return -EIO;
551

552 553 554
	pcm = ACCESS_ONCE(s->pcm);
	if (pcm && pcm_frames > 0)
		update_pcm_pointers(s, pcm, pcm_frames);
555

556
	return 0;
557 558
}

559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576
/*
 * In CYCLE_TIMER register of IEEE 1394, 7 bits are used to represent second. On
 * the other hand, in DMA descriptors of 1394 OHCI, 3 bits are used to represent
 * it. Thus, via Linux firewire subsystem, we can get the 3 bits for second.
 */
static inline u32 compute_cycle_count(u32 tstamp)
{
	return (((tstamp >> 13) & 0x07) * 8000) + (tstamp & 0x1fff);
}

static inline u32 increment_cycle_count(u32 cycle, unsigned int addend)
{
	cycle += addend;
	if (cycle >= 8 * CYCLES_PER_SECOND)
		cycle -= 8 * CYCLES_PER_SECOND;
	return cycle;
}

577 578 579 580 581 582 583
static inline u32 decrement_cycle_count(u32 cycle, unsigned int subtrahend)
{
	if (cycle < subtrahend)
		cycle += 8 * CYCLES_PER_SECOND;
	return cycle - subtrahend;
}

584
static void out_stream_callback(struct fw_iso_context *context, u32 tstamp,
585 586
				size_t header_length, void *header,
				void *private_data)
587
{
588
	struct amdtp_stream *s = private_data;
589
	unsigned int i, syt, packets = header_length / 4;
590
	unsigned int data_blocks;
591
	u32 cycle;
592

593 594 595
	if (s->packet_index < 0)
		return;

596 597 598 599
	cycle = compute_cycle_count(tstamp);

	/* Align to actual cycle count for the last packet. */
	cycle = increment_cycle_count(cycle, QUEUE_LENGTH - packets);
600

601
	for (i = 0; i < packets; ++i) {
602 603
		cycle = increment_cycle_count(cycle, 1);
		syt = calculate_syt(s, cycle);
604 605
		data_blocks = calculate_data_blocks(s, syt);

606
		if (handle_out_packet(s, data_blocks, cycle, syt) < 0) {
607 608 609 610
			s->packet_index = -1;
			amdtp_stream_pcm_abort(s);
			return;
		}
611
	}
612

613
	fw_iso_context_queue_flush(s->context);
614 615
}

616
static void in_stream_callback(struct fw_iso_context *context, u32 tstamp,
617 618 619 620
			       size_t header_length, void *header,
			       void *private_data)
{
	struct amdtp_stream *s = private_data;
621 622
	unsigned int p, syt, packets;
	unsigned int payload_quadlets, max_payload_quadlets;
623
	unsigned int data_blocks;
624
	__be32 *buffer, *headers = header;
625
	u32 cycle;
626

627 628 629
	if (s->packet_index < 0)
		return;

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

633 634 635 636 637
	cycle = compute_cycle_count(tstamp);

	/* Align to actual cycle count for the last packet. */
	cycle = decrement_cycle_count(cycle, packets);

638 639 640
	/* For buffer-over-run prevention. */
	max_payload_quadlets = amdtp_stream_get_max_payload(s) / 4;

641
	for (p = 0; p < packets; p++) {
642
		cycle = increment_cycle_count(cycle, 1);
643 644 645 646 647
		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;
648 649 650 651 652 653 654
		if (payload_quadlets > max_payload_quadlets) {
			dev_err(&s->unit->device,
				"Detect jumbo payload: %02x %02x\n",
				payload_quadlets, max_payload_quadlets);
			break;
		}

655
		syt = be32_to_cpu(buffer[1]) & CIP_SYT_MASK;
656
		if (handle_in_packet(s, payload_quadlets, buffer,
657
						&data_blocks, cycle, syt) < 0)
658
			break;
659 660
	}

661 662 663
	/* Queueing error or detecting invalid payload. */
	if (p < packets) {
		s->packet_index = -1;
664
		amdtp_stream_pcm_abort(s);
665 666 667
		return;
	}

668 669 670
	fw_iso_context_queue_flush(s->context);
}

671 672
/* this is executed one time */
static void amdtp_stream_first_callback(struct fw_iso_context *context,
673
					u32 tstamp, size_t header_length,
674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689
					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
		context->callback.sc = out_stream_callback;

690
	context->callback.sc(context, tstamp, header_length, header, s);
691 692
}

693
/**
694 695
 * amdtp_stream_start - start transferring packets
 * @s: the AMDTP stream to start
696 697 698 699
 * @channel: the isochronous channel on the bus
 * @speed: firewire speed code
 *
 * The stream cannot be started until it has been configured with
700 701
 * amdtp_stream_set_parameters() and it must be started before any PCM or MIDI
 * device can be started.
702
 */
703
int amdtp_stream_start(struct amdtp_stream *s, int channel, int speed)
704 705 706 707 708 709 710 711 712 713 714 715 716
{
	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 },
	};
717 718
	unsigned int header_size;
	enum dma_data_direction dir;
719
	int type, tag, err;
720 721 722

	mutex_lock(&s->mutex);

723
	if (WARN_ON(amdtp_stream_running(s) ||
724
		    (s->data_block_quadlets < 1))) {
725 726 727 728
		err = -EBADFD;
		goto err_unlock;
	}

729 730 731 732 733
	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;
734 735 736 737
	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;

738 739 740 741 742 743 744 745 746 747
	/* 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;
	}
748
	err = iso_packets_buffer_init(&s->buffer, s->unit, QUEUE_LENGTH,
749
				      amdtp_stream_get_max_payload(s), dir);
750 751 752 753
	if (err < 0)
		goto err_unlock;

	s->context = fw_iso_context_create(fw_parent_device(s->unit)->card,
754
					   type, channel, speed, header_size,
755
					   amdtp_stream_first_callback, s);
756 757 758 759
	if (IS_ERR(s->context)) {
		err = PTR_ERR(s->context);
		if (err == -EBUSY)
			dev_err(&s->unit->device,
760
				"no free stream on this controller\n");
761 762 763
		goto err_buffer;
	}

764
	amdtp_stream_update(s);
765

766
	s->packet_index = 0;
767
	do {
768 769 770 771
		if (s->direction == AMDTP_IN_STREAM)
			err = queue_in_packet(s);
		else
			err = queue_out_packet(s, 0, true);
772 773 774
		if (err < 0)
			goto err_context;
	} while (s->packet_index > 0);
775

776
	/* NOTE: TAG1 matches CIP. This just affects in stream. */
777 778 779 780
	tag = FW_ISO_CONTEXT_MATCH_TAG1;
	if (s->flags & CIP_EMPTY_WITH_TAG0)
		tag |= FW_ISO_CONTEXT_MATCH_TAG0;

781
	s->callbacked = false;
782
	err = fw_iso_context_start(s->context, -1, 0, tag);
783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799
	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;
}
800
EXPORT_SYMBOL(amdtp_stream_start);
801

802
/**
803 804
 * amdtp_stream_pcm_pointer - get the PCM buffer position
 * @s: the AMDTP stream that transports the PCM data
805 806 807
 *
 * Returns the current buffer position, in frames.
 */
808
unsigned long amdtp_stream_pcm_pointer(struct amdtp_stream *s)
809
{
810
	/* this optimization is allowed to be racy */
811
	if (s->pointer_flush && amdtp_stream_running(s))
812 813 814
		fw_iso_context_flush_completions(s->context);
	else
		s->pointer_flush = true;
815 816 817

	return ACCESS_ONCE(s->pcm_buffer_pointer);
}
818
EXPORT_SYMBOL(amdtp_stream_pcm_pointer);
819

820
/**
821 822
 * amdtp_stream_update - update the stream after a bus reset
 * @s: the AMDTP stream
823
 */
824
void amdtp_stream_update(struct amdtp_stream *s)
825
{
826
	/* Precomputing. */
827
	ACCESS_ONCE(s->source_node_id_field) =
828 829
		(fw_parent_device(s->unit)->card->node_id << CIP_SID_SHIFT) &
								CIP_SID_MASK;
830
}
831
EXPORT_SYMBOL(amdtp_stream_update);
832 833

/**
834 835
 * amdtp_stream_stop - stop sending packets
 * @s: the AMDTP stream to stop
836 837 838 839
 *
 * All PCM and MIDI devices of the stream must be stopped before the stream
 * itself can be stopped.
 */
840
void amdtp_stream_stop(struct amdtp_stream *s)
841 842 843
{
	mutex_lock(&s->mutex);

844
	if (!amdtp_stream_running(s)) {
845 846 847 848
		mutex_unlock(&s->mutex);
		return;
	}

849
	tasklet_kill(&s->period_tasklet);
850 851 852 853 854
	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);

855 856
	s->callbacked = false;

857 858
	mutex_unlock(&s->mutex);
}
859
EXPORT_SYMBOL(amdtp_stream_stop);
860 861

/**
862
 * amdtp_stream_pcm_abort - abort the running PCM device
863 864 865 866 867
 * @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.
 */
868
void amdtp_stream_pcm_abort(struct amdtp_stream *s)
869 870 871 872
{
	struct snd_pcm_substream *pcm;

	pcm = ACCESS_ONCE(s->pcm);
873 874
	if (pcm)
		snd_pcm_stop_xrun(pcm);
875
}
876
EXPORT_SYMBOL(amdtp_stream_pcm_abort);