amdtp-stream.c 24.0 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 254
{
	tasklet_kill(&s->period_tasklet);
	s->pcm_buffer_pointer = 0;
	s->pcm_period_pointer = 0;
}
255
EXPORT_SYMBOL(amdtp_stream_pcm_prepare);
256

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

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

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

	return data_blocks;
}

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

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

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

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

350 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
	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;
		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};
376 377 378 379
	int err = 0;

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

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

406 407 408 409 410 411
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);
}

412 413
static int handle_out_packet(struct amdtp_stream *s, unsigned int cycle,
			     unsigned int index)
414 415
{
	__be32 *buffer;
416 417
	unsigned int syt;
	unsigned int data_blocks;
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 424
	syt = calculate_syt(s, cycle);
	data_blocks = calculate_data_blocks(s, syt);
425
	pcm_frames = s->process_data_blocks(s, buffer + 2, data_blocks, &syt);
426

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

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

438
	trace_out_packet(s, cycle, buffer, payload_length, index);
439

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

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

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

451
static int handle_in_packet(struct amdtp_stream *s,
452 453
			    unsigned int payload_quadlets, unsigned int cycle,
			    unsigned int index)
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
	trace_in_packet(s, cycle, cip_header, payload_quadlets, index);
469

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, i) < 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, i) < 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 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822
	/*
	 * This function is called in software IRQ context of period_tasklet or
	 * process context.
	 *
	 * When the software IRQ context was scheduled by software IRQ context
	 * of IR/IT contexts, queued packets were already handled. Therefore,
	 * no need to flush the queue in buffer anymore.
	 *
	 * When the process context reach here, some packets will be already
	 * queued in the buffer. These packets should be handled immediately
	 * to keep better granularity of PCM pointer.
	 *
	 * Later, the process context will sometimes schedules software IRQ
	 * context of the period_tasklet. Then, no need to flush the queue by
	 * the same reason as described for IR/IT contexts.
	 */
	if (!in_interrupt() && amdtp_stream_running(s))
823
		fw_iso_context_flush_completions(s->context);
824 825 826

	return ACCESS_ONCE(s->pcm_buffer_pointer);
}
827
EXPORT_SYMBOL(amdtp_stream_pcm_pointer);
828

829
/**
830 831
 * amdtp_stream_update - update the stream after a bus reset
 * @s: the AMDTP stream
832
 */
833
void amdtp_stream_update(struct amdtp_stream *s)
834
{
835
	/* Precomputing. */
836
	ACCESS_ONCE(s->source_node_id_field) =
837 838
		(fw_parent_device(s->unit)->card->node_id << CIP_SID_SHIFT) &
								CIP_SID_MASK;
839
}
840
EXPORT_SYMBOL(amdtp_stream_update);
841 842

/**
843 844
 * amdtp_stream_stop - stop sending packets
 * @s: the AMDTP stream to stop
845 846 847 848
 *
 * All PCM and MIDI devices of the stream must be stopped before the stream
 * itself can be stopped.
 */
849
void amdtp_stream_stop(struct amdtp_stream *s)
850 851 852
{
	mutex_lock(&s->mutex);

853
	if (!amdtp_stream_running(s)) {
854 855 856 857
		mutex_unlock(&s->mutex);
		return;
	}

858
	tasklet_kill(&s->period_tasklet);
859 860 861 862 863
	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);

864 865
	s->callbacked = false;

866 867
	mutex_unlock(&s->mutex);
}
868
EXPORT_SYMBOL(amdtp_stream_stop);
869 870

/**
871
 * amdtp_stream_pcm_abort - abort the running PCM device
872 873 874 875 876
 * @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.
 */
877
void amdtp_stream_pcm_abort(struct amdtp_stream *s)
878 879 880 881
{
	struct snd_pcm_substream *pcm;

	pcm = ACCESS_ONCE(s->pcm);
882 883
	if (pcm)
		snd_pcm_stop_xrun(pcm);
884
}
885
EXPORT_SYMBOL(amdtp_stream_pcm_abort);