amdtp-stream.c 23.4 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 cycle)
415 416
{
	__be32 *buffer;
417 418
	unsigned int syt;
	unsigned int data_blocks;
419
	unsigned int payload_length;
420
	unsigned int pcm_frames;
421 422
	struct snd_pcm_substream *pcm;

423
	buffer = s->buffer.packets[s->packet_index].buffer;
424 425
	syt = calculate_syt(s, cycle);
	data_blocks = calculate_data_blocks(s, syt);
426
	pcm_frames = s->process_data_blocks(s, buffer + 2, data_blocks, &syt);
427

428
	buffer[0] = cpu_to_be32(ACCESS_ONCE(s->source_node_id_field) |
429
				(s->data_block_quadlets << CIP_DBS_SHIFT) |
430
				s->data_block_counter);
431 432 433 434
	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));
435 436

	s->data_block_counter = (s->data_block_counter + data_blocks) & 0xff;
437
	payload_length = 8 + data_blocks * 4 * s->data_block_quadlets;
438 439 440

	trace_out_packet(s, cycle, buffer, payload_length);

441 442
	if (queue_out_packet(s, payload_length, false) < 0)
		return -EIO;
443

444 445 446
	pcm = ACCESS_ONCE(s->pcm);
	if (pcm && pcm_frames > 0)
		update_pcm_pointers(s, pcm, pcm_frames);
447 448 449

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

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

464
	buffer = s->buffer.packets[s->packet_index].buffer;
465 466 467
	cip_header[0] = be32_to_cpu(buffer[0]);
	cip_header[1] = be32_to_cpu(buffer[1]);

468 469
	trace_in_packet(s, cycle, cip_header, payload_quadlets);

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

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

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

513
		data_blocks = (payload_quadlets - 2) / data_block_quadlets;
514 515 516
	}

	/* Check data block counter continuity */
517
	data_block_counter = cip_header[0] & CIP_DBC_MASK;
518
	if (data_blocks == 0 && (s->flags & CIP_EMPTY_HAS_WRONG_DBC) &&
519 520 521
	    s->data_block_counter != UINT_MAX)
		data_block_counter = s->data_block_counter;

522 523 524
	if (((s->flags & CIP_SKIP_DBC_ZERO_CHECK) &&
	     data_block_counter == s->tx_first_dbc) ||
	    s->data_block_counter == UINT_MAX) {
525 526
		lost = false;
	} else if (!(s->flags & CIP_DBC_IS_END_EVENT)) {
527
		lost = data_block_counter != s->data_block_counter;
528
	} else {
529
		if (data_blocks > 0 && s->tx_dbc_interval > 0)
530 531
			dbc_interval = s->tx_dbc_interval;
		else
532
			dbc_interval = data_blocks;
533

534
		lost = data_block_counter !=
535 536
		       ((s->data_block_counter + dbc_interval) & 0xff);
	}
537 538

	if (lost) {
539 540 541
		dev_err(&s->unit->device,
			"Detect discontinuity of CIP: %02X %02X\n",
			s->data_block_counter, data_block_counter);
542
		return -EIO;
543 544
	}

545 546
	syt = be32_to_cpu(buffer[1]) & CIP_SYT_MASK;
	pcm_frames = s->process_data_blocks(s, buffer + 2, data_blocks, &syt);
547

548 549 550 551
	if (s->flags & CIP_DBC_IS_END_EVENT)
		s->data_block_counter = data_block_counter;
	else
		s->data_block_counter =
552
				(data_block_counter + data_blocks) & 0xff;
553 554
end:
	if (queue_in_packet(s) < 0)
555
		return -EIO;
556

557 558 559
	pcm = ACCESS_ONCE(s->pcm);
	if (pcm && pcm_frames > 0)
		update_pcm_pointers(s, pcm, pcm_frames);
560

561
	return 0;
562 563
}

564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581
/*
 * 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;
}

582 583 584 585 586 587 588
static inline u32 decrement_cycle_count(u32 cycle, unsigned int subtrahend)
{
	if (cycle < subtrahend)
		cycle += 8 * CYCLES_PER_SECOND;
	return cycle - subtrahend;
}

589
static void out_stream_callback(struct fw_iso_context *context, u32 tstamp,
590 591
				size_t header_length, void *header,
				void *private_data)
592
{
593
	struct amdtp_stream *s = private_data;
594
	unsigned int i, packets = header_length / 4;
595
	u32 cycle;
596

597 598 599
	if (s->packet_index < 0)
		return;

600 601 602 603
	cycle = compute_cycle_count(tstamp);

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

605
	for (i = 0; i < packets; ++i) {
606
		cycle = increment_cycle_count(cycle, 1);
607
		if (handle_out_packet(s, cycle) < 0) {
608 609 610 611
			s->packet_index = -1;
			amdtp_stream_pcm_abort(s);
			return;
		}
612
	}
613

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

617
static void in_stream_callback(struct fw_iso_context *context, u32 tstamp,
618 619 620 621
			       size_t header_length, void *header,
			       void *private_data)
{
	struct amdtp_stream *s = private_data;
622
	unsigned int i, packets;
623
	unsigned int payload_quadlets, max_payload_quadlets;
624
	__be32 *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 (i = 0; i < packets; i++) {
642
		cycle = increment_cycle_count(cycle, 1);
643 644 645

		/* The number of quadlets in this packet */
		payload_quadlets =
646
			(be32_to_cpu(headers[i]) >> ISO_DATA_LENGTH_SHIFT) / 4;
647 648 649 650 651 652 653
		if (payload_quadlets > max_payload_quadlets) {
			dev_err(&s->unit->device,
				"Detect jumbo payload: %02x %02x\n",
				payload_quadlets, max_payload_quadlets);
			break;
		}

654
		if (handle_in_packet(s, payload_quadlets, cycle) < 0)
655
			break;
656 657
	}

658
	/* Queueing error or detecting invalid payload. */
659
	if (i < packets) {
660
		s->packet_index = -1;
661
		amdtp_stream_pcm_abort(s);
662 663 664
		return;
	}

665 666 667
	fw_iso_context_queue_flush(s->context);
}

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

687
	context->callback.sc(context, tstamp, header_length, header, s);
688 689
}

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

	mutex_lock(&s->mutex);

720
	if (WARN_ON(amdtp_stream_running(s) ||
721
		    (s->data_block_quadlets < 1))) {
722 723 724 725
		err = -EBADFD;
		goto err_unlock;
	}

726
	if (s->direction == AMDTP_IN_STREAM)
727 728 729
		s->data_block_counter = UINT_MAX;
	else
		s->data_block_counter = 0;
730 731 732 733
	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;

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

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

760
	amdtp_stream_update(s);
761

762
	s->packet_index = 0;
763
	do {
764 765 766 767
		if (s->direction == AMDTP_IN_STREAM)
			err = queue_in_packet(s);
		else
			err = queue_out_packet(s, 0, true);
768 769 770
		if (err < 0)
			goto err_context;
	} while (s->packet_index > 0);
771

772
	/* NOTE: TAG1 matches CIP. This just affects in stream. */
773 774 775 776
	tag = FW_ISO_CONTEXT_MATCH_TAG1;
	if (s->flags & CIP_EMPTY_WITH_TAG0)
		tag |= FW_ISO_CONTEXT_MATCH_TAG0;

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

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

	return ACCESS_ONCE(s->pcm_buffer_pointer);
}
814
EXPORT_SYMBOL(amdtp_stream_pcm_pointer);
815

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

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

840
	if (!amdtp_stream_running(s)) {
841 842 843 844
		mutex_unlock(&s->mutex);
		return;
	}

845
	tasklet_kill(&s->period_tasklet);
846 847 848 849 850
	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);

851 852
	s->callbacked = false;

853 854
	mutex_unlock(&s->mutex);
}
855
EXPORT_SYMBOL(amdtp_stream_stop);
856 857

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

	pcm = ACCESS_ONCE(s->pcm);
869 870
	if (pcm)
		snd_pcm_stop_xrun(pcm);
871
}
872
EXPORT_SYMBOL(amdtp_stream_pcm_abort);