[linux-2.6-block.git] / sound / firewire / amdtp-am824.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * AM824 format in Audio and Music Data Transmission Protocol (IEC 61883-6)
 *
 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
 * Copyright (c) 2015 Takashi Sakamoto <o-takashi@sakamocchi.jp>
 */

#include <linux/slab.h>

#include "amdtp-am824.h"

#define CIP_FMT_AM		0x10

/* "Clock-based rate control mode" is just supported. */
#define AMDTP_FDF_AM824		0x00

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

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

struct amdtp_am824 {
	struct snd_rawmidi_substream *midi[AM824_MAX_CHANNELS_FOR_MIDI * 8];
	int midi_fifo_limit;
	int midi_fifo_used[AM824_MAX_CHANNELS_FOR_MIDI * 8];
	unsigned int pcm_channels;
	unsigned int midi_ports;

	u8 pcm_positions[AM824_MAX_CHANNELS_FOR_PCM];
	u8 midi_position;

	unsigned int frame_multiplier;
};

/**
 * amdtp_am824_set_parameters - set stream parameters
 * @s: the AMDTP stream to configure
 * @rate: the sample rate
 * @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)
 * @double_pcm_frames: one data block transfers two PCM frames
 *
 * The parameters must be set before the stream is started, and must not be
 * changed while the stream is running.
 */
int amdtp_am824_set_parameters(struct amdtp_stream *s, unsigned int rate,
			       unsigned int pcm_channels,
			       unsigned int midi_ports,
			       bool double_pcm_frames)
{
	struct amdtp_am824 *p = s->protocol;
	unsigned int midi_channels;
	unsigned int i;
	int err;

	if (amdtp_stream_running(s))
		return -EINVAL;

	if (pcm_channels > AM824_MAX_CHANNELS_FOR_PCM)
		return -EINVAL;

	midi_channels = DIV_ROUND_UP(midi_ports, 8);
	if (midi_channels > AM824_MAX_CHANNELS_FOR_MIDI)
		return -EINVAL;

	if (WARN_ON(amdtp_stream_running(s)) ||
	    WARN_ON(pcm_channels > AM824_MAX_CHANNELS_FOR_PCM) ||
	    WARN_ON(midi_channels > AM824_MAX_CHANNELS_FOR_MIDI))
		return -EINVAL;

	err = amdtp_stream_set_parameters(s, rate,
					  pcm_channels + midi_channels);
	if (err < 0)
		return err;

	s->ctx_data.rx.fdf = AMDTP_FDF_AM824 | s->sfc;

	p->pcm_channels = pcm_channels;
	p->midi_ports = midi_ports;

	/*
	 * In IEC 61883-6, one data block represents one event. In ALSA, one
	 * event equals to one PCM frame. But Dice has a quirk at higher
	 * sampling rate to transfer two PCM frames in one data block.
	 */
	if (double_pcm_frames)
		p->frame_multiplier = 2;
	else
		p->frame_multiplier = 1;

	/* init the position map for PCM and MIDI channels */
	for (i = 0; i < pcm_channels; i++)
		p->pcm_positions[i] = i;
	p->midi_position = p->pcm_channels;

	/*
	 * 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().)
	 */
	p->midi_fifo_limit = rate - MIDI_BYTES_PER_SECOND * s->syt_interval + 1;

	return 0;
}
EXPORT_SYMBOL_GPL(amdtp_am824_set_parameters);

/**
 * amdtp_am824_set_pcm_position - set an index of data channel for a channel
 *				  of PCM frame
 * @s: the AMDTP stream
 * @index: the index of data channel in an data block
 * @position: the channel of PCM frame
 */
void amdtp_am824_set_pcm_position(struct amdtp_stream *s, unsigned int index,
				 unsigned int position)
{
	struct amdtp_am824 *p = s->protocol;

	if (index < p->pcm_channels)
		p->pcm_positions[index] = position;
}
EXPORT_SYMBOL_GPL(amdtp_am824_set_pcm_position);

/**
 * amdtp_am824_set_midi_position - set a index of data channel for MIDI
 *				   conformant data channel
 * @s: the AMDTP stream
 * @position: the index of data channel in an data block
 */
void amdtp_am824_set_midi_position(struct amdtp_stream *s,
				   unsigned int position)
{
	struct amdtp_am824 *p = s->protocol;

	p->midi_position = position;
}
EXPORT_SYMBOL_GPL(amdtp_am824_set_midi_position);

static void write_pcm_s32(struct amdtp_stream *s,
			  struct snd_pcm_substream *pcm,
			  __be32 *buffer, unsigned int frames)
{
	struct amdtp_am824 *p = s->protocol;
	struct snd_pcm_runtime *runtime = pcm->runtime;
	unsigned int channels, remaining_frames, i, c;
	const u32 *src;

	channels = p->pcm_channels;
	src = (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) {
			buffer[p->pcm_positions[c]] =
					cpu_to_be32((*src >> 8) | 0x40000000);
			src++;
		}
		buffer += s->data_block_quadlets;
		if (--remaining_frames == 0)
			src = (void *)runtime->dma_area;
	}
}

static void read_pcm_s32(struct amdtp_stream *s,
			 struct snd_pcm_substream *pcm,
			 __be32 *buffer, unsigned int frames)
{
	struct amdtp_am824 *p = s->protocol;
	struct snd_pcm_runtime *runtime = pcm->runtime;
	unsigned int channels, remaining_frames, i, c;
	u32 *dst;

	channels = p->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) {
			*dst = be32_to_cpu(buffer[p->pcm_positions[c]]) << 8;
			dst++;
		}
		buffer += s->data_block_quadlets;
		if (--remaining_frames == 0)
			dst = (void *)runtime->dma_area;
	}
}

static void write_pcm_silence(struct amdtp_stream *s,
			      __be32 *buffer, unsigned int frames)
{
	struct amdtp_am824 *p = s->protocol;
	unsigned int i, c, channels = p->pcm_channels;

	for (i = 0; i < frames; ++i) {
		for (c = 0; c < channels; ++c)
			buffer[p->pcm_positions[c]] = cpu_to_be32(0x40000000);
		buffer += s->data_block_quadlets;
	}
}

/**
 * amdtp_am824_add_pcm_hw_constraints - add hw constraints for PCM substream
 * @s:		the AMDTP stream for AM824 data block, must be initialized.
 * @runtime:	the PCM substream runtime
 *
 */
int amdtp_am824_add_pcm_hw_constraints(struct amdtp_stream *s,
				       struct snd_pcm_runtime *runtime)
{
	int err;

	err = amdtp_stream_add_pcm_hw_constraints(s, runtime);
	if (err < 0)
		return err;

	/* AM824 in IEC 61883-6 can deliver 24bit data. */
	return snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
}
EXPORT_SYMBOL_GPL(amdtp_am824_add_pcm_hw_constraints);

/**
 * amdtp_am824_midi_trigger - start/stop playback/capture with a MIDI device
 * @s: the AMDTP stream
 * @port: index of MIDI port
 * @midi: the MIDI device to be started, or %NULL to stop the current device
 *
 * Call this function on a running isochronous stream to enable the actual
 * transmission of MIDI data.  This function should be called from the MIDI
 * device's .trigger callback.
 */
void amdtp_am824_midi_trigger(struct amdtp_stream *s, unsigned int port,
			      struct snd_rawmidi_substream *midi)
{
	struct amdtp_am824 *p = s->protocol;

	if (port < p->midi_ports)
		WRITE_ONCE(p->midi[port], midi);
}
EXPORT_SYMBOL_GPL(amdtp_am824_midi_trigger);

/*
 * 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)
{
	struct amdtp_am824 *p = s->protocol;
	int used;

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

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

	return used < p->midi_fifo_limit;
}

static void midi_rate_use_one_byte(struct amdtp_stream *s, unsigned int port)
{
	struct amdtp_am824 *p = s->protocol;

	p->midi_fifo_used[port] += amdtp_rate_table[s->sfc];
}

static void write_midi_messages(struct amdtp_stream *s, __be32 *buffer,
				unsigned int frames)
{
	struct amdtp_am824 *p = s->protocol;
	unsigned int f, port;
	u8 *b;

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

		port = (s->data_block_counter + f) % 8;
		if (f < MAX_MIDI_RX_BLOCKS &&
		    midi_ratelimit_per_packet(s, port) &&
		    p->midi[port] != NULL &&
		    snd_rawmidi_transmit(p->midi[port], &b[1], 1) == 1) {
			midi_rate_use_one_byte(s, port);
			b[0] = 0x81;
		} else {
			b[0] = 0x80;
			b[1] = 0;
		}
		b[2] = 0;
		b[3] = 0;

		buffer += s->data_block_quadlets;
	}
}

static void read_midi_messages(struct amdtp_stream *s,
			       __be32 *buffer, unsigned int frames)
{
	struct amdtp_am824 *p = s->protocol;
	unsigned int f, port;
	int len;
	u8 *b;

	for (f = 0; f < frames; f++) {
		port = (8 - s->ctx_data.tx.first_dbc + s->data_block_counter + f) % 8;
		b = (u8 *)&buffer[p->midi_position];

		len = b[0] - 0x80;
		if ((1 <= len) &&  (len <= 3) && (p->midi[port]))
			snd_rawmidi_receive(p->midi[port], b + 1, len);

		buffer += s->data_block_quadlets;
	}
}

static unsigned int process_rx_data_blocks(struct amdtp_stream *s, __be32 *buffer,
					   unsigned int data_blocks, unsigned int *syt)
{
	struct amdtp_am824 *p = s->protocol;
	struct snd_pcm_substream *pcm = READ_ONCE(s->pcm);
	unsigned int pcm_frames;

	if (pcm) {
		write_pcm_s32(s, pcm, buffer, data_blocks);
		pcm_frames = data_blocks * p->frame_multiplier;
	} else {
		write_pcm_silence(s, buffer, data_blocks);
		pcm_frames = 0;
	}

	if (p->midi_ports)
		write_midi_messages(s, buffer, data_blocks);

	return pcm_frames;
}

static unsigned int process_tx_data_blocks(struct amdtp_stream *s, __be32 *buffer,
					   unsigned int data_blocks, unsigned int *syt)
{
	struct amdtp_am824 *p = s->protocol;
	struct snd_pcm_substream *pcm = READ_ONCE(s->pcm);
	unsigned int pcm_frames;

	if (pcm) {
		read_pcm_s32(s, pcm, buffer, data_blocks);
		pcm_frames = data_blocks * p->frame_multiplier;
	} else {
		pcm_frames = 0;
	}

	if (p->midi_ports)
		read_midi_messages(s, buffer, data_blocks);

	return pcm_frames;
}

/**
 * amdtp_am824_init - initialize an AMDTP stream structure to handle AM824
 *		      data block
 * @s: the AMDTP stream to initialize
 * @unit: the target of the stream
 * @dir: the direction of stream
 * @flags: the packet transmission method to use
 */
int amdtp_am824_init(struct amdtp_stream *s, struct fw_unit *unit,
		     enum amdtp_stream_direction dir, enum cip_flags flags)
{
	amdtp_stream_process_data_blocks_t process_data_blocks;

	if (dir == AMDTP_IN_STREAM)
		process_data_blocks = process_tx_data_blocks;
	else
		process_data_blocks = process_rx_data_blocks;

	return amdtp_stream_init(s, unit, dir, flags, CIP_FMT_AM,
				 process_data_blocks,
				 sizeof(struct amdtp_am824));
}
EXPORT_SYMBOL_GPL(amdtp_am824_init);
Commit	Line	Data
da607e19	1	// SPDX-License-Identifier: GPL-2.0-only
5955815e TS	2	/*
	3	* AM824 format in Audio and Music Data Transmission Protocol (IEC 61883-6)
	4	*
df075fee	5	* Copyright (c) Clemens Ladisch <clemens@ladisch.de>
5955815e	6	* Copyright (c) 2015 Takashi Sakamoto <o-takashi@sakamocchi.jp>
5955815e TS	7	*/
5955815e TS	8
df075fee TS	9	#include <linux/slab.h>
df075fee TS	10
5955815e TS	11	#include "amdtp-am824.h"
	12
	13	#define CIP_FMT_AM 0x10
	14
51c29fd2 TS	15	/* "Clock-based rate control mode" is just supported. */
	16	#define AMDTP_FDF_AM824 0x00
	17
df075fee TS	18	/*
	19	* Nominally 3125 bytes/second, but the MIDI port's clock might be
	20	* 1% too slow, and the bus clock 100 ppm too fast.
	21	*/
	22	#define MIDI_BYTES_PER_SECOND 3093
	23
	24	/*
	25	* Several devices look only at the first eight data blocks.
	26	* In any case, this is more than enough for the MIDI data rate.
	27	*/
	28	#define MAX_MIDI_RX_BLOCKS 8
	29
	30	struct amdtp_am824 {
	31	struct snd_rawmidi_substream midi[AM824_MAX_CHANNELS_FOR_MIDI 8];
	32	int midi_fifo_limit;
	33	int midi_fifo_used[AM824_MAX_CHANNELS_FOR_MIDI * 8];
	34	unsigned int pcm_channels;
	35	unsigned int midi_ports;
	36
	37	u8 pcm_positions[AM824_MAX_CHANNELS_FOR_PCM];
	38	u8 midi_position;
	39
df075fee TS	40	unsigned int frame_multiplier;
	41	};
	42
51c29fd2 TS	43	/**
	44	* amdtp_am824_set_parameters - set stream parameters
	45	* @s: the AMDTP stream to configure
	46	* @rate: the sample rate
	47	* @pcm_channels: the number of PCM samples in each data block, to be encoded
	48	* as AM824 multi-bit linear audio
	49	* @midi_ports: the number of MIDI ports (i.e., MPX-MIDI Data Channels)
	50	* @double_pcm_frames: one data block transfers two PCM frames
	51	*
	52	* The parameters must be set before the stream is started, and must not be
	53	* changed while the stream is running.
	54	*/
	55	int amdtp_am824_set_parameters(struct amdtp_stream *s, unsigned int rate,
	56	unsigned int pcm_channels,
	57	unsigned int midi_ports,
	58	bool double_pcm_frames)
	59	{
df075fee TS	60	struct amdtp_am824 *p = s->protocol;
	61	unsigned int midi_channels;
	62	unsigned int i;
51c29fd2 TS	63	int err;
51c29fd2 TS	64
df075fee TS	65	if (amdtp_stream_running(s))
	66	return -EINVAL;
	67
	68	if (pcm_channels > AM824_MAX_CHANNELS_FOR_PCM)
	69	return -EINVAL;
	70
	71	midi_channels = DIV_ROUND_UP(midi_ports, 8);
	72	if (midi_channels > AM824_MAX_CHANNELS_FOR_MIDI)
	73	return -EINVAL;
	74
	75	if (WARN_ON(amdtp_stream_running(s)) \|\|
	76	WARN_ON(pcm_channels > AM824_MAX_CHANNELS_FOR_PCM) \|\|
	77	WARN_ON(midi_channels > AM824_MAX_CHANNELS_FOR_MIDI))
	78	return -EINVAL;
	79
	80	err = amdtp_stream_set_parameters(s, rate,
	81	pcm_channels + midi_channels);
51c29fd2 TS	82	if (err < 0)
	83	return err;
	84
d3d10a4a	85	s->ctx_data.rx.fdf = AMDTP_FDF_AM824 \| s->sfc;
51c29fd2	86
df075fee TS	87	p->pcm_channels = pcm_channels;
	88	p->midi_ports = midi_ports;
	89
51c29fd2 TS	90	/*
	91	* In IEC 61883-6, one data block represents one event. In ALSA, one
	92	* event equals to one PCM frame. But Dice has a quirk at higher
	93	* sampling rate to transfer two PCM frames in one data block.
	94	*/
	95	if (double_pcm_frames)
df075fee	96	p->frame_multiplier = 2;
51c29fd2	97	else
df075fee TS	98	p->frame_multiplier = 1;
	99
	100	/* init the position map for PCM and MIDI channels */
	101	for (i = 0; i < pcm_channels; i++)
	102	p->pcm_positions[i] = i;
	103	p->midi_position = p->pcm_channels;
	104
	105	/*
	106	* We do not know the actual MIDI FIFO size of most devices. Just
	107	* assume two bytes, i.e., one byte can be received over the bus while
	108	* the previous one is transmitted over MIDI.
	109	* (The value here is adjusted for midi_ratelimit_per_packet().)
	110	*/
	111	p->midi_fifo_limit = rate - MIDI_BYTES_PER_SECOND * s->syt_interval + 1;
51c29fd2 TS	112
	113	return 0;
	114	}
	115	EXPORT_SYMBOL_GPL(amdtp_am824_set_parameters);
	116
f65be911 TS	117	/**
	118	* amdtp_am824_set_pcm_position - set an index of data channel for a channel
	119	* of PCM frame
	120	* @s: the AMDTP stream
	121	* @index: the index of data channel in an data block
	122	* @position: the channel of PCM frame
	123	*/
	124	void amdtp_am824_set_pcm_position(struct amdtp_stream *s, unsigned int index,
	125	unsigned int position)
	126	{
df075fee TS	127	struct amdtp_am824 *p = s->protocol;
	128
	129	if (index < p->pcm_channels)
	130	p->pcm_positions[index] = position;
f65be911 TS	131	}
	132	EXPORT_SYMBOL_GPL(amdtp_am824_set_pcm_position);
	133
	134	/**
	135	* amdtp_am824_set_midi_position - set a index of data channel for MIDI
	136	* conformant data channel
	137	* @s: the AMDTP stream
	138	* @position: the index of data channel in an data block
	139	*/
	140	void amdtp_am824_set_midi_position(struct amdtp_stream *s,
	141	unsigned int position)
	142	{
df075fee TS	143	struct amdtp_am824 *p = s->protocol;
	144
	145	p->midi_position = position;
f65be911 TS	146	}
	147	EXPORT_SYMBOL_GPL(amdtp_am824_set_midi_position);
	148
df075fee TS	149	static void write_pcm_s32(struct amdtp_stream *s,
	150	struct snd_pcm_substream *pcm,
	151	__be32 *buffer, unsigned int frames)
	152	{
	153	struct amdtp_am824 *p = s->protocol;
	154	struct snd_pcm_runtime *runtime = pcm->runtime;
	155	unsigned int channels, remaining_frames, i, c;
	156	const u32 *src;
	157
	158	channels = p->pcm_channels;
	159	src = (void *)runtime->dma_area +
	160	frames_to_bytes(runtime, s->pcm_buffer_pointer);
	161	remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;
	162
	163	for (i = 0; i < frames; ++i) {
	164	for (c = 0; c < channels; ++c) {
	165	buffer[p->pcm_positions[c]] =
	166	cpu_to_be32((*src >> 8) \| 0x40000000);
	167	src++;
	168	}
	169	buffer += s->data_block_quadlets;
	170	if (--remaining_frames == 0)
	171	src = (void *)runtime->dma_area;
	172	}
	173	}
	174
df075fee TS	175	static void read_pcm_s32(struct amdtp_stream *s,
	176	struct snd_pcm_substream *pcm,
	177	__be32 *buffer, unsigned int frames)
	178	{
	179	struct amdtp_am824 *p = s->protocol;
	180	struct snd_pcm_runtime *runtime = pcm->runtime;
	181	unsigned int channels, remaining_frames, i, c;
	182	u32 *dst;
	183
	184	channels = p->pcm_channels;
	185	dst = (void *)runtime->dma_area +
	186	frames_to_bytes(runtime, s->pcm_buffer_pointer);
	187	remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;
	188
	189	for (i = 0; i < frames; ++i) {
	190	for (c = 0; c < channels; ++c) {
	191	*dst = be32_to_cpu(buffer[p->pcm_positions[c]]) << 8;
	192	dst++;
	193	}
	194	buffer += s->data_block_quadlets;
	195	if (--remaining_frames == 0)
	196	dst = (void *)runtime->dma_area;
	197	}
	198	}
	199
	200	static void write_pcm_silence(struct amdtp_stream *s,
	201	__be32 *buffer, unsigned int frames)
	202	{
	203	struct amdtp_am824 *p = s->protocol;
	204	unsigned int i, c, channels = p->pcm_channels;
	205
	206	for (i = 0; i < frames; ++i) {
	207	for (c = 0; c < channels; ++c)
	208	buffer[p->pcm_positions[c]] = cpu_to_be32(0x40000000);
	209	buffer += s->data_block_quadlets;
	210	}
	211	}
	212
bc8500da TS	213	/**
	214	* amdtp_am824_add_pcm_hw_constraints - add hw constraints for PCM substream
	215	* @s: the AMDTP stream for AM824 data block, must be initialized.
	216	* @runtime: the PCM substream runtime
	217	*
	218	*/
	219	int amdtp_am824_add_pcm_hw_constraints(struct amdtp_stream *s,
	220	struct snd_pcm_runtime *runtime)
	221	{
	222	int err;
	223
	224	err = amdtp_stream_add_pcm_hw_constraints(s, runtime);
	225	if (err < 0)
	226	return err;
	227
	228	/* AM824 in IEC 61883-6 can deliver 24bit data. */
	229	return snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
	230	}
	231	EXPORT_SYMBOL_GPL(amdtp_am824_add_pcm_hw_constraints);
	232
03e2a67e TS	233	/**
	234	* amdtp_am824_midi_trigger - start/stop playback/capture with a MIDI device
	235	* @s: the AMDTP stream
	236	* @port: index of MIDI port
	237	* @midi: the MIDI device to be started, or %NULL to stop the current device
	238	*
	239	* Call this function on a running isochronous stream to enable the actual
	240	* transmission of MIDI data. This function should be called from the MIDI
	241	* device's .trigger callback.
	242	*/
	243	void amdtp_am824_midi_trigger(struct amdtp_stream *s, unsigned int port,
	244	struct snd_rawmidi_substream *midi)
	245	{
df075fee TS	246	struct amdtp_am824 *p = s->protocol;
	247
	248	if (port < p->midi_ports)
6aa7de05	249	WRITE_ONCE(p->midi[port], midi);
03e2a67e TS	250	}
	251	EXPORT_SYMBOL_GPL(amdtp_am824_midi_trigger);
	252
df075fee TS	253	/*
	254	* To avoid sending MIDI bytes at too high a rate, assume that the receiving
	255	* device has a FIFO, and track how much it is filled. This values increases
	256	* by one whenever we send one byte in a packet, but the FIFO empties at
	257	* a constant rate independent of our packet rate. One packet has syt_interval
	258	* samples, so the number of bytes that empty out of the FIFO, per packet(!),
	259	* is MIDI_BYTES_PER_SECOND * syt_interval / sample_rate. To avoid storing
	260	* fractional values, the values in midi_fifo_used[] are measured in bytes
	261	* multiplied by the sample rate.
	262	*/
	263	static bool midi_ratelimit_per_packet(struct amdtp_stream *s, unsigned int port)
	264	{
	265	struct amdtp_am824 *p = s->protocol;
	266	int used;
	267
	268	used = p->midi_fifo_used[port];
	269	if (used == 0) /* common shortcut */
	270	return true;
	271
	272	used -= MIDI_BYTES_PER_SECOND * s->syt_interval;
	273	used = max(used, 0);
	274	p->midi_fifo_used[port] = used;
	275
	276	return used < p->midi_fifo_limit;
	277	}
	278
	279	static void midi_rate_use_one_byte(struct amdtp_stream *s, unsigned int port)
	280	{
	281	struct amdtp_am824 *p = s->protocol;
	282
	283	p->midi_fifo_used[port] += amdtp_rate_table[s->sfc];
	284	}
	285
	286	static void write_midi_messages(struct amdtp_stream s, __be32 buffer,
	287	unsigned int frames)
	288	{
	289	struct amdtp_am824 *p = s->protocol;
	290	unsigned int f, port;
	291	u8 *b;
	292
	293	for (f = 0; f < frames; f++) {
	294	b = (u8 *)&buffer[p->midi_position];
	295
	296	port = (s->data_block_counter + f) % 8;
	297	if (f < MAX_MIDI_RX_BLOCKS &&
	298	midi_ratelimit_per_packet(s, port) &&
	299	p->midi[port] != NULL &&
	300	snd_rawmidi_transmit(p->midi[port], &b[1], 1) == 1) {
	301	midi_rate_use_one_byte(s, port);
	302	b[0] = 0x81;
	303	} else {
	304	b[0] = 0x80;
	305	b[1] = 0;
	306	}
	307	b[2] = 0;
	308	b[3] = 0;
	309
	310	buffer += s->data_block_quadlets;
	311	}
	312	}
	313
	314	static void read_midi_messages(struct amdtp_stream *s,
	315	__be32 *buffer, unsigned int frames)
	316	{
317	struct amdtp_am824 *p = s->protocol;
318	unsigned int f, port;
319	int len;
320	u8 *b;
321
322	for (f = 0; f < frames; f++) {
b5c21c84	323	port = (8 - s->ctx_data.tx.first_dbc + s->data_block_counter + f) % 8;
df075fee TS	324	b = (u8 *)&buffer[p->midi_position];
	325
	326	len = b[0] - 0x80;
	327	if ((1 <= len) && (len <= 3) && (p->midi[port]))
	328	snd_rawmidi_receive(p->midi[port], b + 1, len);
	329
	330	buffer += s->data_block_quadlets;
	331	}
	332	}
	333
02e6ef9f	334	static unsigned int process_rx_data_blocks(struct amdtp_stream s, __be32 buffer,
02e6ef9f	335	unsigned int data_blocks, unsigned int *syt)
df075fee TS	336	{
df075fee TS	337	struct amdtp_am824 *p = s->protocol;
6aa7de05	338	struct snd_pcm_substream *pcm = READ_ONCE(s->pcm);
df075fee TS	339	unsigned int pcm_frames;
	340
	341	if (pcm) {
a02cb8f8	342	write_pcm_s32(s, pcm, buffer, data_blocks);
df075fee TS	343	pcm_frames = data_blocks * p->frame_multiplier;
	344	} else {
	345	write_pcm_silence(s, buffer, data_blocks);
	346	pcm_frames = 0;
	347	}
	348
	349	if (p->midi_ports)
	350	write_midi_messages(s, buffer, data_blocks);
	351
	352	return pcm_frames;
	353	}
	354
02e6ef9f	355	static unsigned int process_tx_data_blocks(struct amdtp_stream s, __be32 buffer,
02e6ef9f	356	unsigned int data_blocks, unsigned int *syt)
df075fee TS	357	{
df075fee TS	358	struct amdtp_am824 *p = s->protocol;
6aa7de05	359	struct snd_pcm_substream *pcm = READ_ONCE(s->pcm);
df075fee TS	360	unsigned int pcm_frames;
	361
	362	if (pcm) {
a02cb8f8	363	read_pcm_s32(s, pcm, buffer, data_blocks);
df075fee TS	364	pcm_frames = data_blocks * p->frame_multiplier;
	365	} else {
	366	pcm_frames = 0;
	367	}
	368
	369	if (p->midi_ports)
	370	read_midi_messages(s, buffer, data_blocks);
	371
	372	return pcm_frames;
	373	}
	374
5955815e TS	375	/**
	376	* amdtp_am824_init - initialize an AMDTP stream structure to handle AM824
	377	* data block
	378	* @s: the AMDTP stream to initialize
	379	* @unit: the target of the stream
	380	* @dir: the direction of stream
	381	* @flags: the packet transmission method to use
	382	*/
	383	int amdtp_am824_init(struct amdtp_stream s, struct fw_unit unit,
	384	enum amdtp_stream_direction dir, enum cip_flags flags)
	385	{
df075fee TS	386	amdtp_stream_process_data_blocks_t process_data_blocks;
	387
	388	if (dir == AMDTP_IN_STREAM)
	389	process_data_blocks = process_tx_data_blocks;
	390	else
	391	process_data_blocks = process_rx_data_blocks;
	392
	393	return amdtp_stream_init(s, unit, dir, flags, CIP_FMT_AM,
	394	process_data_blocks,
	395	sizeof(struct amdtp_am824));
5955815e TS	396	}
5955815e TS	397	EXPORT_SYMBOL_GPL(amdtp_am824_init);