Commit dd49b2d1 authored by Takashi Sakamoto's avatar Takashi Sakamoto Committed by Takashi Iwai
Browse files

ALSA: firewire-motu: add PCM functionality 



This commit adds PCM functionality to transmit/receive PCM samples.

When one of PCM substreams are running or external clock source is
selected, current sampling rate is used. Else, the sampling rate is
changed according to requests from a userspace application.

Available number of samples in a frame of PCM substream is determined at
open(2) to corresponding PCM character device. Later, packet streaming
starts by ioctl(2) with SNDRV_PCM_IOCTL_PREPARE. In theory, between them,
applications can change state of the unit by any write transaction to
change the number. In this case, this driver may fail packet streaming due
to wrong data format.

Signed-off-by: default avatarTakashi Sakamoto <o-takashi@sakamocchi.jp>
Signed-off-by: default avatarTakashi Iwai <tiwai@suse.de>
parent 4638ec6e

sound/firewire/motu/Makefile

+1 −1
Original line number Diff line number Diff line 
snd-firewire-motu-objs := motu.o amdtp-motu.o motu-transaction.o motu-stream.o \

			  motu-proc.o

			  motu-proc.o motu-pcm.o

obj-$(CONFIG_SND_FIREWIRE_MOTU) += snd-firewire-motu.o

sound/firewire/motu/motu-pcm.c

0 → 100644
+386 −0
Original line number Diff line number Diff line 
/*

 * motu-pcm.c - a part of driver for MOTU FireWire series

 *

 * Copyright (c) 2015-2017 Takashi Sakamoto <o-takashi@sakamocchi.jp>

 *

 * Licensed under the terms of the GNU General Public License, version 2.

 */



#include <sound/pcm_params.h>

#include "motu.h"



static int motu_rate_constraint(struct snd_pcm_hw_params *params,

				struct snd_pcm_hw_rule *rule)

{

	struct snd_motu_packet_format *formats = rule->private;



	const struct snd_interval *c =

		hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_CHANNELS);

	struct snd_interval *r =

		hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);

	struct snd_interval rates = {

		.min = UINT_MAX, .max = 0, .integer = 1

	};

	unsigned int i, pcm_channels, rate, mode;



	for (i = 0; i < ARRAY_SIZE(snd_motu_clock_rates); ++i) {

		rate = snd_motu_clock_rates[i];

		mode = i / 2;



		pcm_channels = formats->fixed_part_pcm_chunks[mode] +

			       formats->differed_part_pcm_chunks[mode];

		if (!snd_interval_test(c, pcm_channels))

			continue;



		rates.min = min(rates.min, rate);

		rates.max = max(rates.max, rate);

	}



	return snd_interval_refine(r, &rates);

}



static int motu_channels_constraint(struct snd_pcm_hw_params *params,

				    struct snd_pcm_hw_rule *rule)

{

	struct snd_motu_packet_format *formats = rule->private;



	const struct snd_interval *r =

		hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_RATE);

	struct snd_interval *c =

		hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);

	struct snd_interval channels = {

		.min = UINT_MAX, .max = 0, .integer = 1

	};

	unsigned int i, pcm_channels, rate, mode;



	for (i = 0; i < ARRAY_SIZE(snd_motu_clock_rates); ++i) {

		rate = snd_motu_clock_rates[i];

		mode = i / 2;



		if (!snd_interval_test(r, rate))

			continue;



		pcm_channels = formats->fixed_part_pcm_chunks[mode] +

			       formats->differed_part_pcm_chunks[mode];

		channels.min = min(channels.min, pcm_channels);

		channels.max = max(channels.max, pcm_channels);

	}



	return snd_interval_refine(c, &channels);

}



static void limit_channels_and_rates(struct snd_motu *motu,

				     struct snd_pcm_runtime *runtime,

				     struct snd_motu_packet_format *formats)

{

	struct snd_pcm_hardware *hw = &runtime->hw;

	unsigned int i, pcm_channels, rate, mode;



	hw->channels_min = UINT_MAX;

	hw->channels_max = 0;



	for (i = 0; i < ARRAY_SIZE(snd_motu_clock_rates); ++i) {

		rate = snd_motu_clock_rates[i];

		mode = i / 2;



		pcm_channels = formats->fixed_part_pcm_chunks[mode] +

			       formats->differed_part_pcm_chunks[mode];

		if (pcm_channels == 0)

			continue;



		hw->rates |= snd_pcm_rate_to_rate_bit(rate);

		hw->channels_min = min(hw->channels_min, pcm_channels);

		hw->channels_max = max(hw->channels_max, pcm_channels);

	}



	snd_pcm_limit_hw_rates(runtime);

}



static void limit_period_and_buffer(struct snd_pcm_hardware *hw)

{

	hw->periods_min = 2;			/* SNDRV_PCM_INFO_BATCH */

	hw->periods_max = UINT_MAX;



	hw->period_bytes_min = 4 * hw->channels_max;    /* byte for a frame */



	/* Just to prevent from allocating much pages. */

	hw->period_bytes_max = hw->period_bytes_min * 2048;

	hw->buffer_bytes_max = hw->period_bytes_max * hw->periods_min;

}



static int init_hw_info(struct snd_motu *motu,

			struct snd_pcm_substream *substream)

{

	struct snd_pcm_runtime *runtime = substream->runtime;

	struct snd_pcm_hardware *hw = &runtime->hw;

	struct amdtp_stream *stream;

	struct snd_motu_packet_format *formats;

	int err;



	hw->info = SNDRV_PCM_INFO_MMAP |

		   SNDRV_PCM_INFO_MMAP_VALID |

		   SNDRV_PCM_INFO_BATCH |

		   SNDRV_PCM_INFO_INTERLEAVED |

		   SNDRV_PCM_INFO_JOINT_DUPLEX |

		   SNDRV_PCM_INFO_BLOCK_TRANSFER;



	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {

		hw->formats = SNDRV_PCM_FMTBIT_S32;

		stream = &motu->tx_stream;

		formats = &motu->tx_packet_formats;

	} else {

		hw->formats = SNDRV_PCM_FMTBIT_S32;

		stream = &motu->rx_stream;

		formats = &motu->rx_packet_formats;

	}



	limit_channels_and_rates(motu, runtime, formats);

	limit_period_and_buffer(hw);



	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,

				  motu_rate_constraint, formats,

				  SNDRV_PCM_HW_PARAM_CHANNELS, -1);

	if (err < 0)

		return err;

	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,

				  motu_channels_constraint, formats,

				  SNDRV_PCM_HW_PARAM_RATE, -1);

	if (err < 0)

		return err;



	return amdtp_motu_add_pcm_hw_constraints(stream, runtime);

}



static int pcm_open(struct snd_pcm_substream *substream)

{

	struct snd_motu *motu = substream->private_data;

	const struct snd_motu_protocol *const protocol = motu->spec->protocol;

	enum snd_motu_clock_source src;

	unsigned int rate;

	int err;



	mutex_lock(&motu->mutex);



	err = protocol->cache_packet_formats(motu);

	if (err < 0)

		return err;



	err = init_hw_info(motu, substream);

	if (err < 0)

		return err;



	/*

	 * When source of clock is not internal or any PCM streams are running,

	 * available sampling rate is limited at current sampling rate.

	 */

	err = protocol->get_clock_source(motu, &src);

	if (err < 0)

		return err;

	if (src != SND_MOTU_CLOCK_SOURCE_INTERNAL ||

	    amdtp_stream_pcm_running(&motu->tx_stream) ||

	    amdtp_stream_pcm_running(&motu->rx_stream)) {

		err = protocol->get_clock_rate(motu, &rate);

		if (err < 0)

			return err;

		substream->runtime->hw.rate_min = rate;

		substream->runtime->hw.rate_max = rate;

	}



	snd_pcm_set_sync(substream);



	mutex_unlock(&motu->mutex);



	return err;

}



static int pcm_close(struct snd_pcm_substream *substream)

{

	return 0;

}



static int capture_hw_params(struct snd_pcm_substream *substream,

			     struct snd_pcm_hw_params *hw_params)

{

	struct snd_motu *motu = substream->private_data;

	int err;



	err = snd_pcm_lib_alloc_vmalloc_buffer(substream,

					       params_buffer_bytes(hw_params));

	if (err < 0)

		return err;



	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {

		mutex_lock(&motu->mutex);

		motu->capture_substreams++;

		mutex_unlock(&motu->mutex);

	}



	return 0;

}

static int playback_hw_params(struct snd_pcm_substream *substream,

			      struct snd_pcm_hw_params *hw_params)

{

	struct snd_motu *motu = substream->private_data;

	int err;



	err = snd_pcm_lib_alloc_vmalloc_buffer(substream,

					       params_buffer_bytes(hw_params));

	if (err < 0)

		return err;



	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {

		mutex_lock(&motu->mutex);

		motu->playback_substreams++;

		mutex_unlock(&motu->mutex);

	}



	return 0;

}



static int capture_hw_free(struct snd_pcm_substream *substream)

{

	struct snd_motu *motu = substream->private_data;



	mutex_lock(&motu->mutex);



	if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)

		motu->capture_substreams--;



	snd_motu_stream_stop_duplex(motu);



	mutex_unlock(&motu->mutex);



	return snd_pcm_lib_free_vmalloc_buffer(substream);

}



static int playback_hw_free(struct snd_pcm_substream *substream)

{

	struct snd_motu *motu = substream->private_data;



	mutex_lock(&motu->mutex);



	if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)

		motu->playback_substreams--;



	snd_motu_stream_stop_duplex(motu);



	mutex_unlock(&motu->mutex);



	return snd_pcm_lib_free_vmalloc_buffer(substream);

}



static int capture_prepare(struct snd_pcm_substream *substream)

{

	struct snd_motu *motu = substream->private_data;

	int err;



	mutex_lock(&motu->mutex);

	err = snd_motu_stream_start_duplex(motu, substream->runtime->rate);

	mutex_unlock(&motu->mutex);

	if (err >= 0)

		amdtp_stream_pcm_prepare(&motu->tx_stream);



	return 0;

}

static int playback_prepare(struct snd_pcm_substream *substream)

{

	struct snd_motu *motu = substream->private_data;

	int err;



	mutex_lock(&motu->mutex);

	err = snd_motu_stream_start_duplex(motu, substream->runtime->rate);

	mutex_unlock(&motu->mutex);

	if (err >= 0)

		amdtp_stream_pcm_prepare(&motu->rx_stream);



	return err;

}



static int capture_trigger(struct snd_pcm_substream *substream, int cmd)

{

	struct snd_motu *motu = substream->private_data;



	switch (cmd) {

	case SNDRV_PCM_TRIGGER_START:

		amdtp_stream_pcm_trigger(&motu->tx_stream, substream);

		break;

	case SNDRV_PCM_TRIGGER_STOP:

		amdtp_stream_pcm_trigger(&motu->tx_stream, NULL);

		break;

	default:

		return -EINVAL;

	}



	return 0;

}

static int playback_trigger(struct snd_pcm_substream *substream, int cmd)

{

	struct snd_motu *motu = substream->private_data;



	switch (cmd) {

	case SNDRV_PCM_TRIGGER_START:

		amdtp_stream_pcm_trigger(&motu->rx_stream, substream);

		break;

	case SNDRV_PCM_TRIGGER_STOP:

		amdtp_stream_pcm_trigger(&motu->rx_stream, NULL);

		break;

	default:

		return -EINVAL;

	}



	return 0;

}



static snd_pcm_uframes_t capture_pointer(struct snd_pcm_substream *substream)

{

	struct snd_motu *motu = substream->private_data;



	return amdtp_stream_pcm_pointer(&motu->tx_stream);

}

static snd_pcm_uframes_t playback_pointer(struct snd_pcm_substream *substream)

{

	struct snd_motu *motu = substream->private_data;



	return amdtp_stream_pcm_pointer(&motu->rx_stream);

}



int snd_motu_create_pcm_devices(struct snd_motu *motu)

{

	static struct snd_pcm_ops capture_ops = {

		.open      = pcm_open,

		.close     = pcm_close,

		.ioctl     = snd_pcm_lib_ioctl,

		.hw_params = capture_hw_params,

		.hw_free   = capture_hw_free,

		.prepare   = capture_prepare,

		.trigger   = capture_trigger,

		.pointer   = capture_pointer,

		.page      = snd_pcm_lib_get_vmalloc_page,

		.mmap      = snd_pcm_lib_mmap_vmalloc,

	};

	static struct snd_pcm_ops playback_ops = {

		.open      = pcm_open,

		.close     = pcm_close,

		.ioctl     = snd_pcm_lib_ioctl,

		.hw_params = playback_hw_params,

		.hw_free   = playback_hw_free,

		.prepare   = playback_prepare,

		.trigger   = playback_trigger,

		.pointer   = playback_pointer,

		.page      = snd_pcm_lib_get_vmalloc_page,

		.mmap      = snd_pcm_lib_mmap_vmalloc,

	};

	struct snd_pcm *pcm;

	int err;



	err = snd_pcm_new(motu->card, motu->card->driver, 0, 1, 1, &pcm);

	if (err < 0)

		return err;

	pcm->private_data = motu;

	strcpy(pcm->name, motu->card->shortname);



	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_ops);

	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &playback_ops);



	return 0;

}

sound/firewire/motu/motu.c

+4 −0
Original line number Diff line number Diff line
@@ -99,6 +99,10 @@ static void do_registration(struct work_struct *work) 


	snd_motu_proc_init(motu);



	err = snd_motu_create_pcm_devices(motu);

	if (err < 0)

		goto error;



	err = snd_card_register(motu->card);

	if (err < 0)

		goto error;

sound/firewire/motu/motu.h

+2 −0
Original line number Diff line number Diff line
@@ -131,4 +131,6 @@ int snd_motu_stream_start_duplex(struct snd_motu *motu, unsigned int rate); 
void snd_motu_stream_stop_duplex(struct snd_motu *motu);



void snd_motu_proc_init(struct snd_motu *motu);



int snd_motu_create_pcm_devices(struct snd_motu *motu);

#endif

CRA Git | Maintained and supported by SUSTech CRA and CCSE