1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * u_uac1.c -- ALSA audio utilities for Gadget stack
4  *
5  * Copyright (C) 2008 Bryan Wu <cooloney@kernel.org>
6  * Copyright (C) 2008 Analog Devices, Inc
7  */
8 
9 #include <linux/kernel.h>
10 #include <linux/module.h>
11 #include <linux/slab.h>
12 #include <linux/device.h>
13 #include <linux/delay.h>
14 #include <linux/ctype.h>
15 #include <linux/random.h>
16 #include <linux/syscalls.h>
17 
18 #include "u_uac1_legacy.h"
19 
20 /*
21  * This component encapsulates the ALSA devices for USB audio gadget
22  */
23 
24 /*-------------------------------------------------------------------------*/
25 
26 /*
27  * Some ALSA internal helper functions
28  */
29 static int snd_interval_refine_set(struct snd_interval *i, unsigned int val)
30 {
31 	struct snd_interval t;
32 	t.empty = 0;
33 	t.min = t.max = val;
34 	t.openmin = t.openmax = 0;
35 	t.integer = 1;
36 	return snd_interval_refine(i, &t);
37 }
38 
39 static int _snd_pcm_hw_param_set(struct snd_pcm_hw_params *params,
40 				 snd_pcm_hw_param_t var, unsigned int val,
41 				 int dir)
42 {
43 	int changed;
44 	if (hw_is_mask(var)) {
45 		struct snd_mask *m = hw_param_mask(params, var);
46 		if (val == 0 && dir < 0) {
47 			changed = -EINVAL;
48 			snd_mask_none(m);
49 		} else {
50 			if (dir > 0)
51 				val++;
52 			else if (dir < 0)
53 				val--;
54 			changed = snd_mask_refine_set(
55 					hw_param_mask(params, var), val);
56 		}
57 	} else if (hw_is_interval(var)) {
58 		struct snd_interval *i = hw_param_interval(params, var);
59 		if (val == 0 && dir < 0) {
60 			changed = -EINVAL;
61 			snd_interval_none(i);
62 		} else if (dir == 0)
63 			changed = snd_interval_refine_set(i, val);
64 		else {
65 			struct snd_interval t;
66 			t.openmin = 1;
67 			t.openmax = 1;
68 			t.empty = 0;
69 			t.integer = 0;
70 			if (dir < 0) {
71 				t.min = val - 1;
72 				t.max = val;
73 			} else {
74 				t.min = val;
75 				t.max = val+1;
76 			}
77 			changed = snd_interval_refine(i, &t);
78 		}
79 	} else
80 		return -EINVAL;
81 	if (changed) {
82 		params->cmask |= 1 << var;
83 		params->rmask |= 1 << var;
84 	}
85 	return changed;
86 }
87 /*-------------------------------------------------------------------------*/
88 
89 /*
90  * Set default hardware params
91  */
92 static int playback_default_hw_params(struct gaudio_snd_dev *snd)
93 {
94 	struct snd_pcm_substream *substream = snd->substream;
95 	struct snd_pcm_hw_params *params;
96 	snd_pcm_sframes_t result;
97 
98        /*
99 	* SNDRV_PCM_ACCESS_RW_INTERLEAVED,
100 	* SNDRV_PCM_FORMAT_S16_LE
101 	* CHANNELS: 2
102 	* RATE: 48000
103 	*/
104 	snd->access = SNDRV_PCM_ACCESS_RW_INTERLEAVED;
105 	snd->format = SNDRV_PCM_FORMAT_S16_LE;
106 	snd->channels = 2;
107 	snd->rate = 48000;
108 
109 	params = kzalloc(sizeof(*params), GFP_KERNEL);
110 	if (!params)
111 		return -ENOMEM;
112 
113 	_snd_pcm_hw_params_any(params);
114 	_snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_ACCESS,
115 			snd->access, 0);
116 	_snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_FORMAT,
117 			snd->format, 0);
118 	_snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_CHANNELS,
119 			snd->channels, 0);
120 	_snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_RATE,
121 			snd->rate, 0);
122 
123 	snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL);
124 	snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_HW_PARAMS, params);
125 
126 	result = snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_PREPARE, NULL);
127 	if (result < 0) {
128 		ERROR(snd->card,
129 			"Preparing sound card failed: %d\n", (int)result);
130 		kfree(params);
131 		return result;
132 	}
133 
134 	/* Store the hardware parameters */
135 	snd->access = params_access(params);
136 	snd->format = params_format(params);
137 	snd->channels = params_channels(params);
138 	snd->rate = params_rate(params);
139 
140 	kfree(params);
141 
142 	INFO(snd->card,
143 		"Hardware params: access %x, format %x, channels %d, rate %d\n",
144 		snd->access, snd->format, snd->channels, snd->rate);
145 
146 	return 0;
147 }
148 
149 /*
150  * Playback audio buffer data by ALSA PCM device
151  */
152 size_t u_audio_playback(struct gaudio *card, void *buf, size_t count)
153 {
154 	struct gaudio_snd_dev	*snd = &card->playback;
155 	struct snd_pcm_substream *substream = snd->substream;
156 	struct snd_pcm_runtime *runtime = substream->runtime;
157 	ssize_t result;
158 	snd_pcm_sframes_t frames;
159 
160 try_again:
161 	if (runtime->status->state == SNDRV_PCM_STATE_XRUN ||
162 		runtime->status->state == SNDRV_PCM_STATE_SUSPENDED) {
163 		result = snd_pcm_kernel_ioctl(substream,
164 				SNDRV_PCM_IOCTL_PREPARE, NULL);
165 		if (result < 0) {
166 			ERROR(card, "Preparing sound card failed: %d\n",
167 					(int)result);
168 			return result;
169 		}
170 	}
171 
172 	frames = bytes_to_frames(runtime, count);
173 	result = snd_pcm_kernel_write(snd->substream, buf, frames);
174 	if (result != frames) {
175 		ERROR(card, "Playback error: %d\n", (int)result);
176 		goto try_again;
177 	}
178 
179 	return 0;
180 }
181 
182 int u_audio_get_playback_channels(struct gaudio *card)
183 {
184 	return card->playback.channels;
185 }
186 
187 int u_audio_get_playback_rate(struct gaudio *card)
188 {
189 	return card->playback.rate;
190 }
191 
192 /*
193  * Open ALSA PCM and control device files
194  * Initial the PCM or control device
195  */
196 static int gaudio_open_snd_dev(struct gaudio *card)
197 {
198 	struct snd_pcm_file *pcm_file;
199 	struct gaudio_snd_dev *snd;
200 	struct f_uac1_legacy_opts *opts;
201 	char *fn_play, *fn_cap, *fn_cntl;
202 
203 	opts = container_of(card->func.fi, struct f_uac1_legacy_opts,
204 			    func_inst);
205 	fn_play = opts->fn_play;
206 	fn_cap = opts->fn_cap;
207 	fn_cntl = opts->fn_cntl;
208 
209 	/* Open control device */
210 	snd = &card->control;
211 	snd->filp = filp_open(fn_cntl, O_RDWR, 0);
212 	if (IS_ERR(snd->filp)) {
213 		int ret = PTR_ERR(snd->filp);
214 		ERROR(card, "unable to open sound control device file: %s\n",
215 				fn_cntl);
216 		snd->filp = NULL;
217 		return ret;
218 	}
219 	snd->card = card;
220 
221 	/* Open PCM playback device and setup substream */
222 	snd = &card->playback;
223 	snd->filp = filp_open(fn_play, O_WRONLY, 0);
224 	if (IS_ERR(snd->filp)) {
225 		int ret = PTR_ERR(snd->filp);
226 
227 		ERROR(card, "No such PCM playback device: %s\n", fn_play);
228 		snd->filp = NULL;
229 		return ret;
230 	}
231 	pcm_file = snd->filp->private_data;
232 	snd->substream = pcm_file->substream;
233 	snd->card = card;
234 	playback_default_hw_params(snd);
235 
236 	/* Open PCM capture device and setup substream */
237 	snd = &card->capture;
238 	snd->filp = filp_open(fn_cap, O_RDONLY, 0);
239 	if (IS_ERR(snd->filp)) {
240 		ERROR(card, "No such PCM capture device: %s\n", fn_cap);
241 		snd->substream = NULL;
242 		snd->card = NULL;
243 		snd->filp = NULL;
244 	} else {
245 		pcm_file = snd->filp->private_data;
246 		snd->substream = pcm_file->substream;
247 		snd->card = card;
248 	}
249 
250 	return 0;
251 }
252 
253 /*
254  * Close ALSA PCM and control device files
255  */
256 static int gaudio_close_snd_dev(struct gaudio *gau)
257 {
258 	struct gaudio_snd_dev	*snd;
259 
260 	/* Close control device */
261 	snd = &gau->control;
262 	if (snd->filp)
263 		filp_close(snd->filp, NULL);
264 
265 	/* Close PCM playback device and setup substream */
266 	snd = &gau->playback;
267 	if (snd->filp)
268 		filp_close(snd->filp, NULL);
269 
270 	/* Close PCM capture device and setup substream */
271 	snd = &gau->capture;
272 	if (snd->filp)
273 		filp_close(snd->filp, NULL);
274 
275 	return 0;
276 }
277 
278 /*
279  * gaudio_setup - setup ALSA interface and preparing for USB transfer
280  *
281  * This sets up PCM, mixer or MIDI ALSA devices fore USB gadget using.
282  *
283  * Returns negative errno, or zero on success
284  */
285 int gaudio_setup(struct gaudio *card)
286 {
287 	int	ret;
288 
289 	ret = gaudio_open_snd_dev(card);
290 	if (ret)
291 		ERROR(card, "we need at least one control device\n");
292 
293 	return ret;
294 
295 }
296 
297 /*
298  * gaudio_cleanup - remove ALSA device interface
299  *
300  * This is called to free all resources allocated by @gaudio_setup().
301  */
302 void gaudio_cleanup(struct gaudio *the_card)
303 {
304 	if (the_card)
305 		gaudio_close_snd_dev(the_card);
306 }
307 
308