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, v: &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(mask: m); |
49 | } else { |
50 | if (dir > 0) |
51 | val++; |
52 | else if (dir < 0) |
53 | val--; |
54 | changed = snd_mask_refine_set( |
55 | mask: 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, v: &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(size: 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 | val: snd->access, dir: 0); |
116 | _snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_FORMAT, |
117 | val: snd->format, dir: 0); |
118 | _snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_CHANNELS, |
119 | val: snd->channels, dir: 0); |
120 | _snd_pcm_hw_param_set(params, SNDRV_PCM_HW_PARAM_RATE, |
121 | val: snd->rate, dir: 0); |
122 | |
123 | snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_DROP, NULL); |
124 | snd_pcm_kernel_ioctl(substream, SNDRV_PCM_IOCTL_HW_PARAMS, arg: 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(objp: params); |
131 | return result; |
132 | } |
133 | |
134 | /* Store the hardware parameters */ |
135 | snd->access = params_access(p: params); |
136 | snd->format = params_format(p: params); |
137 | snd->channels = params_channels(p: params); |
138 | snd->rate = params_rate(p: params); |
139 | |
140 | kfree(objp: 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->state == SNDRV_PCM_STATE_XRUN || |
162 | runtime->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, size: count); |
173 | result = snd_pcm_kernel_write(substream: 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(ptr: snd->filp)) { |
213 | int ret = PTR_ERR(ptr: 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(ptr: snd->filp)) { |
225 | int ret = PTR_ERR(ptr: 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(ptr: 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(gau: the_card); |
306 | } |
307 | |
308 | |