Release 4.17 drivers/usb/gadget/function/u_uac1_legacy.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * u_uac1.c -- ALSA audio utilities for Gadget stack
 *
 * Copyright (C) 2008 Bryan Wu <cooloney@kernel.org>
 * Copyright (C) 2008 Analog Devices, Inc
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/delay.h>
#include <linux/ctype.h>
#include <linux/random.h>
#include <linux/syscalls.h>

#include "u_uac1_legacy.h"

/*
 * This component encapsulates the ALSA devices for USB audio gadget
 */

/*-------------------------------------------------------------------------*/

/**
 * Some ALSA internal helper functions
 */


static int snd_interval_refine_set(struct snd_interval *i, unsigned int val)
{
	struct snd_interval t;
	t.empty = 0;
	t.min = t.max = val;
	t.openmin = t.openmax = 0;
	t.integer = 1;
	return snd_interval_refine(i, &t);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Bryan Wu
60
100.00%
1
100.00%
Total
60
100.00%
1
100.00%



static int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params,
				 snd_pcm_hw_param_t var, unsigned int val,
				 int dir)
{
	int changed;
	if (hw_is_mask(var)) {
		struct snd_mask *m = hw_param_mask(params, var);
		if (val == 0 && dir < 0) {
			changed = -EINVAL;
			snd_mask_none(m);
		} else {
			if (dir > 0)
				val++;
			else if (dir < 0)
				val--;
			changed = snd_mask_refine_set(
					hw_param_mask(params, var), val);
		}
	} else if (hw_is_interval(var)) {
		struct snd_interval *i = hw_param_interval(params, var);
		if (val == 0 && dir < 0) {
			changed = -EINVAL;
			snd_interval_none(i);
		} else if (dir == 0)
			changed = snd_interval_refine_set(i, val);
		else {
			struct snd_interval t;
			t.openmin = 1;
			t.openmax = 1;
			t.empty = 0;
			t.integer = 0;
			if (dir < 0) {
				t.min = val - 1;
				t.max = val;
			} else {
				t.min = val;
				t.max = val+1;
			}
			changed = snd_interval_refine(i, &t);
		}
	} else
		return -EINVAL;
	if (changed) {
		params->cmask |= 1 << var;
		params->rmask |= 1 << var;
	}
	return changed;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Bryan Wu
273
100.00%
1
100.00%
Total
273
100.00%
1
100.00%

/*-------------------------------------------------------------------------*/

/**
 * Set default hardware params
 */


static int playback_default_hw_params(struct gaudio_snd_dev *snd)
{
	struct snd_pcm_substream *substream = snd->substream;
	struct snd_pcm_hw_params *params;
	snd_pcm_sframes_t result;

       /*
        * SNDRV_PCM_ACCESS_RW_INTERLEAVED,
        * SNDRV_PCM_FORMAT_S16_LE
        * CHANNELS: 2
        * RATE: 48000
        */
	snd->access = SNDRV_PCM_ACCESS_RW_INTERLEAVED;
	snd->format = SNDRV_PCM_FORMAT_S16_LE;
	snd->channels = 2;
	snd->rate = 48000;

	params = kzalloc(sizeof(*params), GFP_KERNEL);
	if (!params)
		return -ENOMEM;

	_snd_pcm_hw_params_any(params);
	_snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_ACCESS,
			snd->access, 0);
	_snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_FORMAT,
			snd->format, 0);
	_snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_CHANNELS,
			snd->channels, 0);
	_snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_RATE,
			snd->rate, 0);

	snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
	snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_HW_PARAMS, params);

	result = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_PREPARE, NULL);
	if (result < 0) {
		ERROR(snd->card,
			"Preparing sound card failed: %d\n", (int)result);
		kfree(params);
		return result;
	}

	/* Store the hardware parameters */
	snd->access = params_access(params);
	snd->format = params_format(params);
	snd->channels = params_channels(params);
	snd->rate = params_rate(params);

	kfree(params);

	INFO(snd->card,
		"Hardware params: access %x, format %x, channels %d, rate %d\n",
		snd->access, snd->format, snd->channels, snd->rate);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Bryan Wu
261
100.00%
1
100.00%
Total
261
100.00%
1
100.00%

/**
 * Playback audio buffer data by ALSA PCM device
 */


size_t u_audio_playback(struct gaudio *card, void *buf, size_t count)
{
	struct gaudio_snd_dev	*snd = &card->playback;
	struct snd_pcm_substream *substream = snd->substream;
	struct snd_pcm_runtime *runtime = substream->runtime;
	ssize_t result;
	snd_pcm_sframes_t frames;

try_again:
	if (runtime->status->state == SNDRV_PCM_STATE_XRUN ||
		runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
		result = snd_pcm_kernel_ioctl(substream,
				SNDRV_PCM_IOCTL_PREPARE, NULL);
		if (result < 0) {
			ERROR(card, "Preparing sound card failed: %d\n",
					(int)result);
			return result;
		}
	}

	frames = bytes_to_frames(runtime, count);
	result = snd_pcm_kernel_write(snd->substream, buf, frames);
	if (result != frames) {
		ERROR(card, "Playback error: %d\n", (int)result);
		goto try_again;
	}

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Bryan Wu
154
99.35%
1
50.00%
Takashi Iwai
1
0.65%
1
50.00%
Total
155
100.00%
2
100.00%



int u_audio_get_playback_channels(struct gaudio *card)
{
	return card->playback.channels;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Bryan Wu
17
100.00%
1
100.00%
Total
17
100.00%
1
100.00%



int u_audio_get_playback_rate(struct gaudio *card)
{
	return card->playback.rate;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Bryan Wu
17
100.00%
1
100.00%
Total
17
100.00%
1
100.00%

/**
 * Open ALSA PCM and control device files
 * Initial the PCM or control device
 */


static int gaudio_open_snd_dev(struct gaudio *card)
{
	struct snd_pcm_file *pcm_file;
	struct gaudio_snd_dev *snd;
	struct f_uac1_legacy_opts *opts;
	char *fn_play, *fn_cap, *fn_cntl;

	opts = container_of(card->func.fi, struct f_uac1_legacy_opts,
			    func_inst);
	fn_play = opts->fn_play;
	fn_cap = opts->fn_cap;
	fn_cntl = opts->fn_cntl;

	/* Open control device */
	snd = &card->control;
	snd->filp = filp_open(fn_cntl, O_RDWR, 0);
	if (IS_ERR(snd->filp)) {
		int ret = PTR_ERR(snd->filp);
		ERROR(card, "unable to open sound control device file: %s\n",
				fn_cntl);
		snd->filp = NULL;
		return ret;
	}
	snd->card = card;

	/* Open PCM playback device and setup substream */
	snd = &card->playback;
	snd->filp = filp_open(fn_play, O_WRONLY, 0);
	if (IS_ERR(snd->filp)) {
		int ret = PTR_ERR(snd->filp);

		ERROR(card, "No such PCM playback device: %s\n", fn_play);
		snd->filp = NULL;
		return ret;
	}
	pcm_file = snd->filp->private_data;
	snd->substream = pcm_file->substream;
	snd->card = card;
	playback_default_hw_params(snd);

	/* Open PCM capture device and setup substream */
	snd = &card->capture;
	snd->filp = filp_open(fn_cap, O_RDONLY, 0);
	if (IS_ERR(snd->filp)) {
		ERROR(card, "No such PCM capture device: %s\n", fn_cap);
		snd->substream = NULL;
		snd->card = NULL;
		snd->filp = NULL;
	} else {
		pcm_file = snd->filp->private_data;
		snd->substream = pcm_file->substream;
		snd->card = card;
	}

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Bryan Wu
232
74.84%
1
16.67%
Andrzej Pietrasiewicz
47
15.16%
1
16.67%
Dan Carpenter
13
4.19%
1
16.67%
Robin Callender
10
3.23%
1
16.67%
Richard Röjfors
6
1.94%
1
16.67%
Ruslan Bilovol
2
0.65%
1
16.67%
Total
310
100.00%
6
100.00%

/**
 * Close ALSA PCM and control device files
 */


static int gaudio_close_snd_dev(struct gaudio *gau)
{
	struct gaudio_snd_dev	*snd;

	/* Close control device */
	snd = &gau->control;
	if (snd->filp)
		filp_close(snd->filp, NULL);

	/* Close PCM playback device and setup substream */
	snd = &gau->playback;
	if (snd->filp)
		filp_close(snd->filp, NULL);

	/* Close PCM capture device and setup substream */
	snd = &gau->capture;
	if (snd->filp)
		filp_close(snd->filp, NULL);

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Bryan Wu
85
96.59%
1
50.00%
Al Viro
3
3.41%
1
50.00%
Total
88
100.00%
2
100.00%

/**
 * gaudio_setup - setup ALSA interface and preparing for USB transfer
 *
 * This sets up PCM, mixer or MIDI ALSA devices fore USB gadget using.
 *
 * Returns negative errno, or zero on success
 */


int gaudio_setup(struct gaudio *card)
{
	int	ret;

	ret = gaudio_open_snd_dev(card);
	if (ret)
		ERROR(card, "we need at least one control device\n");

	return ret;

}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Bryan Wu
34
100.00%
1
100.00%
Total
34
100.00%
1
100.00%

/**
 * gaudio_cleanup - remove ALSA device interface
 *
 * This is called to free all resources allocated by @gaudio_setup().
 */


void gaudio_cleanup(struct gaudio *the_card)
{
	if (the_card)
		gaudio_close_snd_dev(the_card);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Bryan Wu
8
42.11%
1
25.00%
Andrzej Pietrasiewicz
8
42.11%
2
50.00%
Cliff Cai
3
15.79%
1
25.00%
Total
19
100.00%
4
100.00%

Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Bryan Wu
1171
91.99%
1
7.69%
Andrzej Pietrasiewicz
58
4.56%
2
15.38%
Dan Carpenter
13
1.02%
1
7.69%
Robin Callender
10
0.79%
1
7.69%
Richard Röjfors
6
0.47%
1
7.69%
Tejun Heo
3
0.24%
1
7.69%
Al Viro
3
0.24%
1
7.69%
Cliff Cai
3
0.24%
1
7.69%
Ruslan Bilovol
3
0.24%
1
7.69%
Takashi Iwai
1
0.08%
1
7.69%
Greg Kroah-Hartman
1
0.08%
1
7.69%
Aaron Wu
1
0.08%
1
7.69%
Total
1273
100.00%
13
100.00%
Directory: drivers/usb/gadget/function

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.