1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * u_audio.c -- interface to USB gadget "ALSA sound card" utilities
4 *
5 * Copyright (C) 2016
6 * Author: Ruslan Bilovol <ruslan.bilovol@gmail.com>
7 *
8 * Sound card implementation was cut-and-pasted with changes
9 * from f_uac2.c and has:
10 * Copyright (C) 2011
11 * Yadwinder Singh (yadi.brar01@gmail.com)
12 * Jaswinder Singh (jaswinder.singh@linaro.org)
13 */
14
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <sound/core.h>
18 #include <sound/pcm.h>
19 #include <sound/pcm_params.h>
20 #include <sound/control.h>
21 #include <sound/tlv.h>
22 #include <linux/usb/audio.h>
23
24 #include "u_audio.h"
25
26 #define BUFF_SIZE_MAX (PAGE_SIZE * 16)
27 #define PRD_SIZE_MAX PAGE_SIZE
28 #define MIN_PERIODS 4
29
30 enum {
31 UAC_FBACK_CTRL,
32 UAC_P_PITCH_CTRL,
33 UAC_MUTE_CTRL,
34 UAC_VOLUME_CTRL,
35 UAC_RATE_CTRL,
36 };
37
38 #define CLK_PPM_GROUP_SIZE 20
39
40 /* Runtime data params for one stream */
41 struct uac_rtd_params {
42 struct snd_uac_chip *uac; /* parent chip */
43 bool ep_enabled; /* if the ep is enabled */
44
45 struct snd_pcm_substream *ss;
46
47 /* Ring buffer */
48 ssize_t hw_ptr;
49
50 void *rbuf;
51
52 unsigned int pitch; /* Stream pitch ratio to 1000000 */
53 unsigned int max_psize; /* MaxPacketSize of endpoint */
54
55 struct usb_request **reqs;
56
57 struct usb_request *req_fback; /* Feedback endpoint request */
58 bool fb_ep_enabled; /* if the ep is enabled */
59
60 /* Volume/Mute controls and their state */
61 int fu_id; /* Feature Unit ID */
62 struct snd_kcontrol *snd_kctl_volume;
63 struct snd_kcontrol *snd_kctl_mute;
64 s16 volume_min, volume_max, volume_res;
65 s16 volume;
66 int mute;
67
68 struct snd_kcontrol *snd_kctl_rate; /* read-only current rate */
69 int srate; /* selected samplerate */
70 int active; /* playback/capture running */
71
72 spinlock_t lock; /* lock for control transfers */
73
74 };
75
76 struct snd_uac_chip {
77 struct g_audio *audio_dev;
78
79 struct uac_rtd_params p_prm;
80 struct uac_rtd_params c_prm;
81
82 struct snd_card *card;
83 struct snd_pcm *pcm;
84
85 /* pre-calculated values for playback iso completion */
86 unsigned long long p_residue_mil;
87 unsigned int p_interval;
88 unsigned int p_framesize;
89 };
90
91 static const struct snd_pcm_hardware uac_pcm_hardware = {
92 .info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER
93 | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID
94 | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME,
95 .rates = SNDRV_PCM_RATE_CONTINUOUS,
96 .periods_max = BUFF_SIZE_MAX / PRD_SIZE_MAX,
97 .buffer_bytes_max = BUFF_SIZE_MAX,
98 .period_bytes_max = PRD_SIZE_MAX,
99 .periods_min = MIN_PERIODS,
100 };
101
102 static struct class *audio_class;
103
u_audio_set_fback_frequency(enum usb_device_speed speed,struct usb_ep * out_ep,unsigned long long freq,unsigned int pitch,void * buf)104 static void u_audio_set_fback_frequency(enum usb_device_speed speed,
105 struct usb_ep *out_ep,
106 unsigned long long freq,
107 unsigned int pitch,
108 void *buf)
109 {
110 u32 ff = 0;
111 const struct usb_endpoint_descriptor *ep_desc;
112
113 /*
114 * Because the pitch base is 1000000, the final divider here
115 * will be 1000 * 1000000 = 1953125 << 9
116 *
117 * Instead of dealing with big numbers lets fold this 9 left shift
118 */
119
120 if (speed == USB_SPEED_FULL) {
121 /*
122 * Full-speed feedback endpoints report frequency
123 * in samples/frame
124 * Format is encoded in Q10.10 left-justified in the 24 bits,
125 * so that it has a Q10.14 format.
126 *
127 * ff = (freq << 14) / 1000
128 */
129 freq <<= 5;
130 } else {
131 /*
132 * High-speed feedback endpoints report frequency
133 * in samples/microframe.
134 * Format is encoded in Q12.13 fitted into four bytes so that
135 * the binary point is located between the second and the third
136 * byte fromat (that is Q16.16)
137 *
138 * ff = (freq << 16) / 8000
139 *
140 * Win10 and OSX UAC2 drivers require number of samples per packet
141 * in order to honor the feedback value.
142 * Linux snd-usb-audio detects the applied bit-shift automatically.
143 */
144 ep_desc = out_ep->desc;
145 freq <<= 4 + (ep_desc->bInterval - 1);
146 }
147
148 ff = DIV_ROUND_CLOSEST_ULL((freq * pitch), 1953125);
149
150 *(__le32 *)buf = cpu_to_le32(ff);
151 }
152
u_audio_iso_complete(struct usb_ep * ep,struct usb_request * req)153 static void u_audio_iso_complete(struct usb_ep *ep, struct usb_request *req)
154 {
155 unsigned int pending;
156 unsigned int hw_ptr;
157 int status = req->status;
158 struct snd_pcm_substream *substream;
159 struct snd_pcm_runtime *runtime;
160 struct uac_rtd_params *prm = req->context;
161 struct snd_uac_chip *uac = prm->uac;
162 unsigned int frames, p_pktsize;
163 unsigned long long pitched_rate_mil, p_pktsize_residue_mil,
164 residue_frames_mil, div_result;
165
166 /* i/f shutting down */
167 if (!prm->ep_enabled) {
168 usb_ep_free_request(ep, req);
169 return;
170 }
171
172 if (req->status == -ESHUTDOWN)
173 return;
174
175 /*
176 * We can't really do much about bad xfers.
177 * Afterall, the ISOCH xfers could fail legitimately.
178 */
179 if (status)
180 pr_debug("%s: iso_complete status(%d) %d/%d\n",
181 __func__, status, req->actual, req->length);
182
183 substream = prm->ss;
184
185 /* Do nothing if ALSA isn't active */
186 if (!substream)
187 goto exit;
188
189 snd_pcm_stream_lock(substream);
190
191 runtime = substream->runtime;
192 if (!runtime || !snd_pcm_running(substream)) {
193 snd_pcm_stream_unlock(substream);
194 goto exit;
195 }
196
197 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
198 /*
199 * For each IN packet, take the quotient of the current data
200 * rate and the endpoint's interval as the base packet size.
201 * If there is a residue from this division, add it to the
202 * residue accumulator.
203 */
204 unsigned long long p_interval_mil = uac->p_interval * 1000000ULL;
205
206 pitched_rate_mil = (unsigned long long) prm->srate * prm->pitch;
207 div_result = pitched_rate_mil;
208 do_div(div_result, uac->p_interval);
209 do_div(div_result, 1000000);
210 frames = (unsigned int) div_result;
211
212 pr_debug("p_srate %d, pitch %d, interval_mil %llu, frames %d\n",
213 prm->srate, prm->pitch, p_interval_mil, frames);
214
215 p_pktsize = min_t(unsigned int,
216 uac->p_framesize * frames,
217 ep->maxpacket);
218
219 if (p_pktsize < ep->maxpacket) {
220 residue_frames_mil = pitched_rate_mil - frames * p_interval_mil;
221 p_pktsize_residue_mil = uac->p_framesize * residue_frames_mil;
222 } else
223 p_pktsize_residue_mil = 0;
224
225 req->length = p_pktsize;
226 uac->p_residue_mil += p_pktsize_residue_mil;
227
228 /*
229 * Whenever there are more bytes in the accumulator p_residue_mil than we
230 * need to add one more sample frame, increase this packet's
231 * size and decrease the accumulator.
232 */
233 div_result = uac->p_residue_mil;
234 do_div(div_result, uac->p_interval);
235 do_div(div_result, 1000000);
236 if ((unsigned int) div_result >= uac->p_framesize) {
237 req->length += uac->p_framesize;
238 uac->p_residue_mil -= uac->p_framesize * p_interval_mil;
239 pr_debug("increased req length to %d\n", req->length);
240 }
241 pr_debug("remains uac->p_residue_mil %llu\n", uac->p_residue_mil);
242
243 req->actual = req->length;
244 }
245
246 hw_ptr = prm->hw_ptr;
247
248 /* Pack USB load in ALSA ring buffer */
249 pending = runtime->dma_bytes - hw_ptr;
250
251 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
252 if (unlikely(pending < req->actual)) {
253 memcpy(req->buf, runtime->dma_area + hw_ptr, pending);
254 memcpy(req->buf + pending, runtime->dma_area,
255 req->actual - pending);
256 } else {
257 memcpy(req->buf, runtime->dma_area + hw_ptr,
258 req->actual);
259 }
260 } else {
261 if (unlikely(pending < req->actual)) {
262 memcpy(runtime->dma_area + hw_ptr, req->buf, pending);
263 memcpy(runtime->dma_area, req->buf + pending,
264 req->actual - pending);
265 } else {
266 memcpy(runtime->dma_area + hw_ptr, req->buf,
267 req->actual);
268 }
269 }
270
271 /* update hw_ptr after data is copied to memory */
272 prm->hw_ptr = (hw_ptr + req->actual) % runtime->dma_bytes;
273 hw_ptr = prm->hw_ptr;
274 snd_pcm_stream_unlock(substream);
275
276 if ((hw_ptr % snd_pcm_lib_period_bytes(substream)) < req->actual)
277 snd_pcm_period_elapsed(substream);
278
279 exit:
280 if (usb_ep_queue(ep, req, GFP_ATOMIC))
281 dev_err(uac->card->dev, "%d Error!\n", __LINE__);
282 }
283
u_audio_iso_fback_complete(struct usb_ep * ep,struct usb_request * req)284 static void u_audio_iso_fback_complete(struct usb_ep *ep,
285 struct usb_request *req)
286 {
287 struct uac_rtd_params *prm = req->context;
288 struct snd_uac_chip *uac = prm->uac;
289 struct g_audio *audio_dev = uac->audio_dev;
290 int status = req->status;
291
292 /* i/f shutting down */
293 if (!prm->fb_ep_enabled) {
294 kfree(req->buf);
295 usb_ep_free_request(ep, req);
296 return;
297 }
298
299 if (req->status == -ESHUTDOWN)
300 return;
301
302 /*
303 * We can't really do much about bad xfers.
304 * Afterall, the ISOCH xfers could fail legitimately.
305 */
306 if (status)
307 pr_debug("%s: iso_complete status(%d) %d/%d\n",
308 __func__, status, req->actual, req->length);
309
310 u_audio_set_fback_frequency(audio_dev->gadget->speed, audio_dev->out_ep,
311 prm->srate, prm->pitch,
312 req->buf);
313
314 if (usb_ep_queue(ep, req, GFP_ATOMIC))
315 dev_err(uac->card->dev, "%d Error!\n", __LINE__);
316 }
317
uac_pcm_trigger(struct snd_pcm_substream * substream,int cmd)318 static int uac_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
319 {
320 struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
321 struct uac_rtd_params *prm;
322 struct g_audio *audio_dev;
323 struct uac_params *params;
324 int err = 0;
325
326 audio_dev = uac->audio_dev;
327 params = &audio_dev->params;
328
329 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
330 prm = &uac->p_prm;
331 else
332 prm = &uac->c_prm;
333
334 /* Reset */
335 prm->hw_ptr = 0;
336
337 switch (cmd) {
338 case SNDRV_PCM_TRIGGER_START:
339 case SNDRV_PCM_TRIGGER_RESUME:
340 prm->ss = substream;
341 break;
342 case SNDRV_PCM_TRIGGER_STOP:
343 case SNDRV_PCM_TRIGGER_SUSPEND:
344 prm->ss = NULL;
345 break;
346 default:
347 err = -EINVAL;
348 }
349
350 /* Clear buffer after Play stops */
351 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && !prm->ss)
352 memset(prm->rbuf, 0, prm->max_psize * params->req_number);
353
354 return err;
355 }
356
uac_pcm_pointer(struct snd_pcm_substream * substream)357 static snd_pcm_uframes_t uac_pcm_pointer(struct snd_pcm_substream *substream)
358 {
359 struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
360 struct uac_rtd_params *prm;
361
362 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
363 prm = &uac->p_prm;
364 else
365 prm = &uac->c_prm;
366
367 return bytes_to_frames(substream->runtime, prm->hw_ptr);
368 }
369
uac_ssize_to_fmt(int ssize)370 static u64 uac_ssize_to_fmt(int ssize)
371 {
372 u64 ret;
373
374 switch (ssize) {
375 case 3:
376 ret = SNDRV_PCM_FMTBIT_S24_3LE;
377 break;
378 case 4:
379 ret = SNDRV_PCM_FMTBIT_S32_LE;
380 break;
381 default:
382 ret = SNDRV_PCM_FMTBIT_S16_LE;
383 break;
384 }
385
386 return ret;
387 }
388
uac_pcm_open(struct snd_pcm_substream * substream)389 static int uac_pcm_open(struct snd_pcm_substream *substream)
390 {
391 struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
392 struct snd_pcm_runtime *runtime = substream->runtime;
393 struct g_audio *audio_dev;
394 struct uac_params *params;
395 struct uac_rtd_params *prm;
396 int p_ssize, c_ssize;
397 int p_chmask, c_chmask;
398
399 audio_dev = uac->audio_dev;
400 params = &audio_dev->params;
401 p_ssize = params->p_ssize;
402 c_ssize = params->c_ssize;
403 p_chmask = params->p_chmask;
404 c_chmask = params->c_chmask;
405 uac->p_residue_mil = 0;
406
407 runtime->hw = uac_pcm_hardware;
408
409 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
410 runtime->hw.formats = uac_ssize_to_fmt(p_ssize);
411 runtime->hw.channels_min = num_channels(p_chmask);
412 prm = &uac->p_prm;
413 } else {
414 runtime->hw.formats = uac_ssize_to_fmt(c_ssize);
415 runtime->hw.channels_min = num_channels(c_chmask);
416 prm = &uac->c_prm;
417 }
418
419 runtime->hw.period_bytes_min = 2 * prm->max_psize
420 / runtime->hw.periods_min;
421 runtime->hw.rate_min = prm->srate;
422 runtime->hw.rate_max = runtime->hw.rate_min;
423 runtime->hw.channels_max = runtime->hw.channels_min;
424
425 snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
426
427 return 0;
428 }
429
430 /* ALSA cries without these function pointers */
uac_pcm_null(struct snd_pcm_substream * substream)431 static int uac_pcm_null(struct snd_pcm_substream *substream)
432 {
433 return 0;
434 }
435
436 static const struct snd_pcm_ops uac_pcm_ops = {
437 .open = uac_pcm_open,
438 .close = uac_pcm_null,
439 .trigger = uac_pcm_trigger,
440 .pointer = uac_pcm_pointer,
441 .prepare = uac_pcm_null,
442 };
443
free_ep(struct uac_rtd_params * prm,struct usb_ep * ep)444 static inline void free_ep(struct uac_rtd_params *prm, struct usb_ep *ep)
445 {
446 struct snd_uac_chip *uac = prm->uac;
447 struct g_audio *audio_dev;
448 struct uac_params *params;
449 int i;
450
451 if (!prm->ep_enabled)
452 return;
453
454 audio_dev = uac->audio_dev;
455 params = &audio_dev->params;
456
457 for (i = 0; i < params->req_number; i++) {
458 if (prm->reqs[i]) {
459 if (usb_ep_dequeue(ep, prm->reqs[i]))
460 usb_ep_free_request(ep, prm->reqs[i]);
461 /*
462 * If usb_ep_dequeue() cannot successfully dequeue the
463 * request, the request will be freed by the completion
464 * callback.
465 */
466
467 prm->reqs[i] = NULL;
468 }
469 }
470
471 prm->ep_enabled = false;
472
473 if (usb_ep_disable(ep))
474 dev_err(uac->card->dev, "%s:%d Error!\n", __func__, __LINE__);
475 }
476
free_ep_fback(struct uac_rtd_params * prm,struct usb_ep * ep)477 static inline void free_ep_fback(struct uac_rtd_params *prm, struct usb_ep *ep)
478 {
479 struct snd_uac_chip *uac = prm->uac;
480
481 if (!prm->fb_ep_enabled)
482 return;
483
484 prm->fb_ep_enabled = false;
485
486 if (prm->req_fback) {
487 if (usb_ep_dequeue(ep, prm->req_fback)) {
488 kfree(prm->req_fback->buf);
489 usb_ep_free_request(ep, prm->req_fback);
490 }
491 prm->req_fback = NULL;
492 }
493
494 if (usb_ep_disable(ep))
495 dev_err(uac->card->dev, "%s:%d Error!\n", __func__, __LINE__);
496 }
497
set_active(struct uac_rtd_params * prm,bool active)498 static void set_active(struct uac_rtd_params *prm, bool active)
499 {
500 // notifying through the Rate ctrl
501 struct snd_kcontrol *kctl = prm->snd_kctl_rate;
502 unsigned long flags;
503
504 spin_lock_irqsave(&prm->lock, flags);
505 if (prm->active != active) {
506 prm->active = active;
507 snd_ctl_notify(prm->uac->card, SNDRV_CTL_EVENT_MASK_VALUE,
508 &kctl->id);
509 }
510 spin_unlock_irqrestore(&prm->lock, flags);
511 }
512
u_audio_set_capture_srate(struct g_audio * audio_dev,int srate)513 int u_audio_set_capture_srate(struct g_audio *audio_dev, int srate)
514 {
515 struct uac_params *params = &audio_dev->params;
516 struct snd_uac_chip *uac = audio_dev->uac;
517 struct uac_rtd_params *prm;
518 int i;
519 unsigned long flags;
520
521 dev_dbg(&audio_dev->gadget->dev, "%s: srate %d\n", __func__, srate);
522 prm = &uac->c_prm;
523 for (i = 0; i < UAC_MAX_RATES; i++) {
524 if (params->c_srates[i] == srate) {
525 spin_lock_irqsave(&prm->lock, flags);
526 prm->srate = srate;
527 audio_dev->usb_state[SET_SAMPLE_RATE_OUT] = true;
528 schedule_work(&audio_dev->work);
529 spin_unlock_irqrestore(&prm->lock, flags);
530 return 0;
531 }
532 if (params->c_srates[i] == 0)
533 break;
534 }
535
536 return -EINVAL;
537 }
538 EXPORT_SYMBOL_GPL(u_audio_set_capture_srate);
539
u_audio_get_capture_srate(struct g_audio * audio_dev,u32 * val)540 int u_audio_get_capture_srate(struct g_audio *audio_dev, u32 *val)
541 {
542 struct snd_uac_chip *uac = audio_dev->uac;
543 struct uac_rtd_params *prm;
544 unsigned long flags;
545
546 prm = &uac->c_prm;
547 spin_lock_irqsave(&prm->lock, flags);
548 *val = prm->srate;
549 spin_unlock_irqrestore(&prm->lock, flags);
550 return 0;
551 }
552 EXPORT_SYMBOL_GPL(u_audio_get_capture_srate);
553
u_audio_set_playback_srate(struct g_audio * audio_dev,int srate)554 int u_audio_set_playback_srate(struct g_audio *audio_dev, int srate)
555 {
556 struct uac_params *params = &audio_dev->params;
557 struct snd_uac_chip *uac = audio_dev->uac;
558 struct uac_rtd_params *prm;
559 int i;
560 unsigned long flags;
561
562 dev_dbg(&audio_dev->gadget->dev, "%s: srate %d\n", __func__, srate);
563 prm = &uac->p_prm;
564 for (i = 0; i < UAC_MAX_RATES; i++) {
565 if (params->p_srates[i] == srate) {
566 spin_lock_irqsave(&prm->lock, flags);
567 prm->srate = srate;
568 audio_dev->usb_state[SET_SAMPLE_RATE_IN] = true;
569 schedule_work(&audio_dev->work);
570 spin_unlock_irqrestore(&prm->lock, flags);
571 return 0;
572 }
573 if (params->p_srates[i] == 0)
574 break;
575 }
576
577 return -EINVAL;
578 }
579 EXPORT_SYMBOL_GPL(u_audio_set_playback_srate);
580
u_audio_get_playback_srate(struct g_audio * audio_dev,u32 * val)581 int u_audio_get_playback_srate(struct g_audio *audio_dev, u32 *val)
582 {
583 struct snd_uac_chip *uac = audio_dev->uac;
584 struct uac_rtd_params *prm;
585 unsigned long flags;
586
587 prm = &uac->p_prm;
588 spin_lock_irqsave(&prm->lock, flags);
589 *val = prm->srate;
590 spin_unlock_irqrestore(&prm->lock, flags);
591 return 0;
592 }
593 EXPORT_SYMBOL_GPL(u_audio_get_playback_srate);
594
u_audio_start_capture(struct g_audio * audio_dev)595 int u_audio_start_capture(struct g_audio *audio_dev)
596 {
597 struct snd_uac_chip *uac = audio_dev->uac;
598 struct usb_gadget *gadget = audio_dev->gadget;
599 struct device *dev = &gadget->dev;
600 struct usb_request *req, *req_fback;
601 struct usb_ep *ep, *ep_fback;
602 struct uac_rtd_params *prm;
603 struct uac_params *params = &audio_dev->params;
604 int req_len, i;
605
606 /*
607 * For better compatibility on some PC Hosts which
608 * failed to send SetInterface(AltSet=0) to stop
609 * capture last time. It needs to stop capture
610 * prior to start capture next time.
611 */
612 if (audio_dev->stream_state[STATE_OUT])
613 u_audio_stop_capture(audio_dev);
614
615 audio_dev->usb_state[SET_INTERFACE_OUT] = true;
616 audio_dev->stream_state[STATE_OUT] = true;
617 schedule_work(&audio_dev->work);
618
619 prm = &uac->c_prm;
620 dev_dbg(dev, "start capture with rate %d\n", prm->srate);
621 ep = audio_dev->out_ep;
622 config_ep_by_speed(gadget, &audio_dev->func, ep);
623 req_len = ep->maxpacket;
624
625 prm->ep_enabled = true;
626 usb_ep_enable(ep);
627
628 for (i = 0; i < params->req_number; i++) {
629 if (!prm->reqs[i]) {
630 req = usb_ep_alloc_request(ep, GFP_ATOMIC);
631 if (req == NULL)
632 return -ENOMEM;
633
634 prm->reqs[i] = req;
635
636 req->zero = 0;
637 req->context = prm;
638 req->length = req_len;
639 req->complete = u_audio_iso_complete;
640 req->buf = prm->rbuf + i * ep->maxpacket;
641 }
642
643 if (usb_ep_queue(ep, prm->reqs[i], GFP_ATOMIC))
644 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
645 }
646
647 set_active(&uac->c_prm, true);
648
649 ep_fback = audio_dev->in_ep_fback;
650 if (!ep_fback)
651 return 0;
652
653 /* Setup feedback endpoint */
654 config_ep_by_speed(gadget, &audio_dev->func, ep_fback);
655 prm->fb_ep_enabled = true;
656 usb_ep_enable(ep_fback);
657 req_len = ep_fback->maxpacket;
658
659 req_fback = usb_ep_alloc_request(ep_fback, GFP_ATOMIC);
660 if (req_fback == NULL)
661 return -ENOMEM;
662
663 prm->req_fback = req_fback;
664 req_fback->zero = 0;
665 req_fback->context = prm;
666 req_fback->length = req_len;
667 req_fback->complete = u_audio_iso_fback_complete;
668
669 req_fback->buf = kzalloc(req_len, GFP_ATOMIC);
670 if (!req_fback->buf)
671 return -ENOMEM;
672
673 /*
674 * Configure the feedback endpoint's reported frequency.
675 * Always start with original frequency since its deviation can't
676 * be meauserd at start of playback
677 */
678 prm->pitch = 1000000;
679 u_audio_set_fback_frequency(audio_dev->gadget->speed, ep,
680 prm->srate, prm->pitch,
681 req_fback->buf);
682
683 if (usb_ep_queue(ep_fback, req_fback, GFP_ATOMIC))
684 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
685
686 return 0;
687 }
688 EXPORT_SYMBOL_GPL(u_audio_start_capture);
689
u_audio_stop_capture(struct g_audio * audio_dev)690 void u_audio_stop_capture(struct g_audio *audio_dev)
691 {
692 struct snd_uac_chip *uac = audio_dev->uac;
693
694 set_active(&uac->c_prm, false);
695 if (audio_dev->in_ep_fback)
696 free_ep_fback(&uac->c_prm, audio_dev->in_ep_fback);
697 free_ep(&uac->c_prm, audio_dev->out_ep);
698
699 audio_dev->usb_state[SET_INTERFACE_OUT] = true;
700 audio_dev->stream_state[STATE_OUT] = false;
701 schedule_work(&audio_dev->work);
702 }
703 EXPORT_SYMBOL_GPL(u_audio_stop_capture);
704
u_audio_start_playback(struct g_audio * audio_dev)705 int u_audio_start_playback(struct g_audio *audio_dev)
706 {
707 struct snd_uac_chip *uac = audio_dev->uac;
708 struct usb_gadget *gadget = audio_dev->gadget;
709 struct device *dev = &gadget->dev;
710 struct usb_request *req;
711 struct usb_ep *ep;
712 struct uac_rtd_params *prm;
713 struct uac_params *params = &audio_dev->params;
714 unsigned int factor;
715 const struct usb_endpoint_descriptor *ep_desc;
716 int req_len, i;
717 unsigned int p_pktsize;
718
719 /*
720 * For better compatibility on some PC Hosts which
721 * failed to send SetInterface(AltSet=0) to stop
722 * playback last time. It needs to stop playback
723 * prior to start playback next time.
724 */
725 if (audio_dev->stream_state[STATE_IN])
726 u_audio_stop_playback(audio_dev);
727
728 audio_dev->usb_state[SET_INTERFACE_IN] = true;
729 audio_dev->stream_state[STATE_IN] = true;
730 schedule_work(&audio_dev->work);
731
732 prm = &uac->p_prm;
733 dev_dbg(dev, "start playback with rate %d\n", prm->srate);
734 ep = audio_dev->in_ep;
735 config_ep_by_speed(gadget, &audio_dev->func, ep);
736
737 ep_desc = ep->desc;
738 /*
739 * Always start with original frequency
740 */
741 prm->pitch = 1000000;
742
743 /* pre-calculate the playback endpoint's interval */
744 if (gadget->speed == USB_SPEED_FULL)
745 factor = 1000;
746 else
747 factor = 8000;
748
749 /* pre-compute some values for iso_complete() */
750 uac->p_framesize = params->p_ssize *
751 num_channels(params->p_chmask);
752 uac->p_interval = factor / (1 << (ep_desc->bInterval - 1));
753 p_pktsize = min_t(unsigned int,
754 uac->p_framesize *
755 (prm->srate / uac->p_interval),
756 ep->maxpacket);
757
758 req_len = p_pktsize;
759 uac->p_residue_mil = 0;
760
761 prm->ep_enabled = true;
762 usb_ep_enable(ep);
763
764 for (i = 0; i < params->req_number; i++) {
765 if (!prm->reqs[i]) {
766 req = usb_ep_alloc_request(ep, GFP_ATOMIC);
767 if (req == NULL)
768 return -ENOMEM;
769
770 prm->reqs[i] = req;
771
772 req->zero = 0;
773 req->context = prm;
774 req->length = req_len;
775 req->complete = u_audio_iso_complete;
776 req->buf = prm->rbuf + i * ep->maxpacket;
777 }
778
779 if (usb_ep_queue(ep, prm->reqs[i], GFP_ATOMIC))
780 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
781 }
782
783 set_active(&uac->p_prm, true);
784
785 return 0;
786 }
787 EXPORT_SYMBOL_GPL(u_audio_start_playback);
788
u_audio_stop_playback(struct g_audio * audio_dev)789 void u_audio_stop_playback(struct g_audio *audio_dev)
790 {
791 struct snd_uac_chip *uac = audio_dev->uac;
792
793 set_active(&uac->p_prm, false);
794 free_ep(&uac->p_prm, audio_dev->in_ep);
795
796 audio_dev->usb_state[SET_INTERFACE_IN] = true;
797 audio_dev->stream_state[STATE_IN] = false;
798 schedule_work(&audio_dev->work);
799 }
800 EXPORT_SYMBOL_GPL(u_audio_stop_playback);
801
u_audio_suspend(struct g_audio * audio_dev)802 void u_audio_suspend(struct g_audio *audio_dev)
803 {
804 struct snd_uac_chip *uac = audio_dev->uac;
805
806 set_active(&uac->p_prm, false);
807 set_active(&uac->c_prm, false);
808 }
809 EXPORT_SYMBOL_GPL(u_audio_suspend);
810
u_audio_get_volume(struct g_audio * audio_dev,int playback,s16 * val)811 int u_audio_get_volume(struct g_audio *audio_dev, int playback, s16 *val)
812 {
813 struct snd_uac_chip *uac = audio_dev->uac;
814 struct uac_rtd_params *prm;
815 unsigned long flags;
816
817 if (playback)
818 prm = &uac->p_prm;
819 else
820 prm = &uac->c_prm;
821
822 spin_lock_irqsave(&prm->lock, flags);
823 *val = prm->volume;
824 spin_unlock_irqrestore(&prm->lock, flags);
825
826 return 0;
827 }
828 EXPORT_SYMBOL_GPL(u_audio_get_volume);
829
u_audio_set_volume(struct g_audio * audio_dev,int playback,s16 val)830 int u_audio_set_volume(struct g_audio *audio_dev, int playback, s16 val)
831 {
832 struct snd_uac_chip *uac = audio_dev->uac;
833 struct uac_rtd_params *prm;
834 unsigned long flags;
835 int change = 0;
836
837 if (playback)
838 prm = &uac->p_prm;
839 else
840 prm = &uac->c_prm;
841
842 spin_lock_irqsave(&prm->lock, flags);
843 val = clamp(val, prm->volume_min, prm->volume_max);
844 if (prm->volume != val) {
845 prm->volume = val;
846 change = 1;
847 }
848 spin_unlock_irqrestore(&prm->lock, flags);
849
850 if (change) {
851 if (playback)
852 audio_dev->usb_state[SET_VOLUME_IN] = true;
853 else
854 audio_dev->usb_state[SET_VOLUME_OUT] = true;
855 schedule_work(&audio_dev->work);
856
857 snd_ctl_notify(uac->card, SNDRV_CTL_EVENT_MASK_VALUE,
858 &prm->snd_kctl_volume->id);
859 }
860
861 return 0;
862 }
863 EXPORT_SYMBOL_GPL(u_audio_set_volume);
864
u_audio_get_mute(struct g_audio * audio_dev,int playback,int * val)865 int u_audio_get_mute(struct g_audio *audio_dev, int playback, int *val)
866 {
867 struct snd_uac_chip *uac = audio_dev->uac;
868 struct uac_rtd_params *prm;
869 unsigned long flags;
870
871 if (playback)
872 prm = &uac->p_prm;
873 else
874 prm = &uac->c_prm;
875
876 spin_lock_irqsave(&prm->lock, flags);
877 *val = prm->mute;
878 spin_unlock_irqrestore(&prm->lock, flags);
879
880 return 0;
881 }
882 EXPORT_SYMBOL_GPL(u_audio_get_mute);
883
u_audio_set_mute(struct g_audio * audio_dev,int playback,int val)884 int u_audio_set_mute(struct g_audio *audio_dev, int playback, int val)
885 {
886 struct snd_uac_chip *uac = audio_dev->uac;
887 struct uac_rtd_params *prm;
888 unsigned long flags;
889 int change = 0;
890 int mute;
891
892 if (playback)
893 prm = &uac->p_prm;
894 else
895 prm = &uac->c_prm;
896
897 mute = val ? 1 : 0;
898
899 spin_lock_irqsave(&prm->lock, flags);
900 if (prm->mute != mute) {
901 prm->mute = mute;
902 change = 1;
903 }
904 spin_unlock_irqrestore(&prm->lock, flags);
905
906 if (change) {
907 if (playback)
908 audio_dev->usb_state[SET_MUTE_IN] = true;
909 else
910 audio_dev->usb_state[SET_MUTE_OUT] = true;
911 schedule_work(&audio_dev->work);
912
913 snd_ctl_notify(uac->card, SNDRV_CTL_EVENT_MASK_VALUE,
914 &prm->snd_kctl_mute->id);
915 }
916
917 return 0;
918 }
919 EXPORT_SYMBOL_GPL(u_audio_set_mute);
920
921
u_audio_pitch_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)922 static int u_audio_pitch_info(struct snd_kcontrol *kcontrol,
923 struct snd_ctl_elem_info *uinfo)
924 {
925 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
926 struct snd_uac_chip *uac = prm->uac;
927 struct g_audio *audio_dev = uac->audio_dev;
928 struct uac_params *params = &audio_dev->params;
929 unsigned int pitch_min, pitch_max;
930
931 pitch_min = (1000 - FBACK_SLOW_MAX) * 1000;
932 pitch_max = (1000 + params->fb_max) * 1000;
933
934 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
935 uinfo->count = 1;
936 uinfo->value.integer.min = pitch_min;
937 uinfo->value.integer.max = pitch_max;
938 uinfo->value.integer.step = 1;
939 return 0;
940 }
941
u_audio_pitch_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)942 static int u_audio_pitch_get(struct snd_kcontrol *kcontrol,
943 struct snd_ctl_elem_value *ucontrol)
944 {
945 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
946
947 ucontrol->value.integer.value[0] = prm->pitch;
948
949 return 0;
950 }
951
u_audio_pitch_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)952 static int u_audio_pitch_put(struct snd_kcontrol *kcontrol,
953 struct snd_ctl_elem_value *ucontrol)
954 {
955 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
956 struct snd_uac_chip *uac = prm->uac;
957 struct g_audio *audio_dev = uac->audio_dev;
958 struct uac_params *params = &audio_dev->params;
959 unsigned int val;
960 unsigned int pitch_min, pitch_max;
961 int change = 0;
962
963 pitch_min = (1000 - FBACK_SLOW_MAX) * 1000;
964 pitch_max = (1000 + params->fb_max) * 1000;
965
966 val = ucontrol->value.integer.value[0];
967
968 if (val < pitch_min)
969 val = pitch_min;
970 if (val > pitch_max)
971 val = pitch_max;
972
973 if (prm->pitch != val) {
974 prm->pitch = val;
975 change = 1;
976 }
977
978 return change;
979 }
980
u_audio_mute_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)981 static int u_audio_mute_info(struct snd_kcontrol *kcontrol,
982 struct snd_ctl_elem_info *uinfo)
983 {
984 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
985 uinfo->count = 1;
986 uinfo->value.integer.min = 0;
987 uinfo->value.integer.max = 1;
988 uinfo->value.integer.step = 1;
989
990 return 0;
991 }
992
u_audio_mute_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)993 static int u_audio_mute_get(struct snd_kcontrol *kcontrol,
994 struct snd_ctl_elem_value *ucontrol)
995 {
996 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
997 unsigned long flags;
998
999 spin_lock_irqsave(&prm->lock, flags);
1000 ucontrol->value.integer.value[0] = !prm->mute;
1001 spin_unlock_irqrestore(&prm->lock, flags);
1002
1003 return 0;
1004 }
1005
u_audio_mute_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1006 static int u_audio_mute_put(struct snd_kcontrol *kcontrol,
1007 struct snd_ctl_elem_value *ucontrol)
1008 {
1009 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
1010 struct snd_uac_chip *uac = prm->uac;
1011 struct g_audio *audio_dev = uac->audio_dev;
1012 unsigned int val;
1013 unsigned long flags;
1014 int change = 0;
1015
1016 val = !ucontrol->value.integer.value[0];
1017
1018 spin_lock_irqsave(&prm->lock, flags);
1019 if (val != prm->mute) {
1020 prm->mute = val;
1021 change = 1;
1022 }
1023 spin_unlock_irqrestore(&prm->lock, flags);
1024
1025 if (change && audio_dev->notify)
1026 audio_dev->notify(audio_dev, prm->fu_id, UAC_FU_MUTE);
1027
1028 return change;
1029 }
1030
1031 /*
1032 * TLV callback for mixer volume controls
1033 */
u_audio_volume_tlv(struct snd_kcontrol * kcontrol,int op_flag,unsigned int size,unsigned int __user * _tlv)1034 static int u_audio_volume_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1035 unsigned int size, unsigned int __user *_tlv)
1036 {
1037 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
1038 DECLARE_TLV_DB_MINMAX(scale, 0, 0);
1039
1040 if (size < sizeof(scale))
1041 return -ENOMEM;
1042
1043 /* UAC volume resolution is 1/256 dB, TLV is 1/100 dB */
1044 scale[2] = (prm->volume_min * 100) / 256;
1045 scale[3] = (prm->volume_max * 100) / 256;
1046 if (copy_to_user(_tlv, scale, sizeof(scale)))
1047 return -EFAULT;
1048
1049 return 0;
1050 }
1051
u_audio_volume_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)1052 static int u_audio_volume_info(struct snd_kcontrol *kcontrol,
1053 struct snd_ctl_elem_info *uinfo)
1054 {
1055 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
1056
1057 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1058 uinfo->count = 1;
1059 uinfo->value.integer.min = 0;
1060 uinfo->value.integer.max =
1061 (prm->volume_max - prm->volume_min + prm->volume_res - 1)
1062 / prm->volume_res;
1063 uinfo->value.integer.step = 1;
1064
1065 return 0;
1066 }
1067
u_audio_volume_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1068 static int u_audio_volume_get(struct snd_kcontrol *kcontrol,
1069 struct snd_ctl_elem_value *ucontrol)
1070 {
1071 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
1072 unsigned long flags;
1073
1074 spin_lock_irqsave(&prm->lock, flags);
1075 ucontrol->value.integer.value[0] =
1076 (prm->volume - prm->volume_min) / prm->volume_res;
1077 spin_unlock_irqrestore(&prm->lock, flags);
1078
1079 return 0;
1080 }
1081
u_audio_volume_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1082 static int u_audio_volume_put(struct snd_kcontrol *kcontrol,
1083 struct snd_ctl_elem_value *ucontrol)
1084 {
1085 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
1086 struct snd_uac_chip *uac = prm->uac;
1087 struct g_audio *audio_dev = uac->audio_dev;
1088 unsigned int val;
1089 s16 volume;
1090 unsigned long flags;
1091 int change = 0;
1092
1093 val = ucontrol->value.integer.value[0];
1094
1095 spin_lock_irqsave(&prm->lock, flags);
1096 volume = (val * prm->volume_res) + prm->volume_min;
1097 volume = clamp(volume, prm->volume_min, prm->volume_max);
1098 if (volume != prm->volume) {
1099 prm->volume = volume;
1100 change = 1;
1101 }
1102 spin_unlock_irqrestore(&prm->lock, flags);
1103
1104 if (change && audio_dev->notify)
1105 audio_dev->notify(audio_dev, prm->fu_id, UAC_FU_VOLUME);
1106
1107 return change;
1108 }
1109
get_max_srate(const int * srates)1110 static int get_max_srate(const int *srates)
1111 {
1112 int i, max_srate = 0;
1113
1114 for (i = 0; i < UAC_MAX_RATES; i++) {
1115 if (srates[i] == 0)
1116 break;
1117 if (srates[i] > max_srate)
1118 max_srate = srates[i];
1119 }
1120 return max_srate;
1121 }
1122
get_min_srate(const int * srates)1123 static int get_min_srate(const int *srates)
1124 {
1125 int i, min_srate = INT_MAX;
1126
1127 for (i = 0; i < UAC_MAX_RATES; i++) {
1128 if (srates[i] == 0)
1129 break;
1130 if (srates[i] < min_srate)
1131 min_srate = srates[i];
1132 }
1133 return min_srate;
1134 }
1135
u_audio_rate_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)1136 static int u_audio_rate_info(struct snd_kcontrol *kcontrol,
1137 struct snd_ctl_elem_info *uinfo)
1138 {
1139 const int *srates;
1140 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
1141 struct snd_uac_chip *uac = prm->uac;
1142 struct g_audio *audio_dev = uac->audio_dev;
1143 struct uac_params *params = &audio_dev->params;
1144
1145 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1146 uinfo->count = 1;
1147
1148 if (prm == &uac->c_prm)
1149 srates = params->c_srates;
1150 else
1151 srates = params->p_srates;
1152 uinfo->value.integer.min = get_min_srate(srates);
1153 uinfo->value.integer.max = get_max_srate(srates);
1154 return 0;
1155 }
1156
u_audio_rate_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1157 static int u_audio_rate_get(struct snd_kcontrol *kcontrol,
1158 struct snd_ctl_elem_value *ucontrol)
1159 {
1160 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
1161 unsigned long flags;
1162
1163 spin_lock_irqsave(&prm->lock, flags);
1164 if (prm->active)
1165 ucontrol->value.integer.value[0] = prm->srate;
1166 else
1167 /* not active: reporting zero rate */
1168 ucontrol->value.integer.value[0] = 0;
1169 spin_unlock_irqrestore(&prm->lock, flags);
1170 return 0;
1171 }
1172
1173 static struct snd_kcontrol_new u_audio_controls[] = {
1174 [UAC_FBACK_CTRL] {
1175 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1176 .name = "Capture Pitch 1000000",
1177 .info = u_audio_pitch_info,
1178 .get = u_audio_pitch_get,
1179 .put = u_audio_pitch_put,
1180 },
1181 [UAC_P_PITCH_CTRL] {
1182 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1183 .name = "Playback Pitch 1000000",
1184 .info = u_audio_pitch_info,
1185 .get = u_audio_pitch_get,
1186 .put = u_audio_pitch_put,
1187 },
1188 [UAC_MUTE_CTRL] {
1189 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1190 .name = "", /* will be filled later */
1191 .info = u_audio_mute_info,
1192 .get = u_audio_mute_get,
1193 .put = u_audio_mute_put,
1194 },
1195 [UAC_VOLUME_CTRL] {
1196 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1197 .name = "", /* will be filled later */
1198 .info = u_audio_volume_info,
1199 .get = u_audio_volume_get,
1200 .put = u_audio_volume_put,
1201 },
1202 [UAC_RATE_CTRL] {
1203 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1204 .name = "", /* will be filled later */
1205 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1206 .info = u_audio_rate_info,
1207 .get = u_audio_rate_get,
1208 },
1209 };
1210
g_audio_work(struct work_struct * data)1211 static void g_audio_work(struct work_struct *data)
1212 {
1213 struct g_audio *audio = container_of(data, struct g_audio, work);
1214 struct usb_gadget *gadget = audio->gadget;
1215 struct snd_uac_chip *uac = audio->uac;
1216 struct uac_rtd_params *prm;
1217 struct device *dev = &gadget->dev;
1218 char *uac_event[4] = { NULL, NULL, NULL, NULL };
1219 char str[19];
1220 int i;
1221
1222 for (i = 0; i < SET_USB_STATE_MAX; i++) {
1223 if (!audio->usb_state[i])
1224 continue;
1225
1226 switch (i) {
1227 case SET_INTERFACE_OUT:
1228 uac_event[0] = "USB_STATE=SET_INTERFACE";
1229 uac_event[1] = "STREAM_DIRECTION=OUT";
1230 uac_event[2] = audio->stream_state[STATE_OUT] ?
1231 "STREAM_STATE=ON" : "STREAM_STATE=OFF";
1232 break;
1233 case SET_INTERFACE_IN:
1234 uac_event[0] = "USB_STATE=SET_INTERFACE";
1235 uac_event[1] = "STREAM_DIRECTION=IN";
1236 uac_event[2] = audio->stream_state[STATE_IN] ?
1237 "STREAM_STATE=ON" : "STREAM_STATE=OFF";
1238 break;
1239 case SET_SAMPLE_RATE_OUT:
1240 uac_event[0] = "USB_STATE=SET_SAMPLE_RATE";
1241 uac_event[1] = "STREAM_DIRECTION=OUT";
1242 prm = &uac->c_prm;
1243 snprintf(str, sizeof(str), "SAMPLE_RATE=%d",
1244 prm->srate);
1245 uac_event[2] = str;
1246 break;
1247 case SET_SAMPLE_RATE_IN:
1248 uac_event[0] = "USB_STATE=SET_SAMPLE_RATE";
1249 uac_event[1] = "STREAM_DIRECTION=IN";
1250 prm = &uac->p_prm;
1251 snprintf(str, sizeof(str), "SAMPLE_RATE=%d",
1252 prm->srate);
1253 uac_event[2] = str;
1254 break;
1255 case SET_MUTE_OUT:
1256 uac_event[0] = "USB_STATE=SET_MUTE";
1257 uac_event[1] = "STREAM_DIRECTION=OUT";
1258 prm = &uac->c_prm;
1259 snprintf(str, sizeof(str), "MUTE=%d", prm->mute);
1260 uac_event[2] = str;
1261 break;
1262 case SET_MUTE_IN:
1263 uac_event[0] = "USB_STATE=SET_MUTE";
1264 uac_event[1] = "STREAM_DIRECTION=IN";
1265 prm = &uac->p_prm;
1266 snprintf(str, sizeof(str), "MUTE=%d", prm->mute);
1267 uac_event[2] = str;
1268 break;
1269 case SET_VOLUME_OUT:
1270 uac_event[0] = "USB_STATE=SET_VOLUME";
1271 uac_event[1] = "STREAM_DIRECTION=OUT";
1272 prm = &uac->c_prm;
1273 snprintf(str, sizeof(str), "VOLUME=0x%hx", prm->volume);
1274 uac_event[2] = str;
1275 break;
1276 case SET_VOLUME_IN:
1277 uac_event[0] = "USB_STATE=SET_VOLUME";
1278 uac_event[1] = "STREAM_DIRECTION=IN";
1279 prm = &uac->p_prm;
1280 snprintf(str, sizeof(str), "VOLUME=0x%hx", prm->volume);
1281 uac_event[2] = str;
1282 break;
1283 case SET_AUDIO_CLK:
1284 uac_event[0] = "USB_STATE=SET_AUDIO_CLK";
1285 snprintf(str, sizeof(str), "PPM=%d", audio->params.ppm);
1286 uac_event[1] = str;
1287 default:
1288 break;
1289 }
1290
1291 audio->usb_state[i] = false;
1292 kobject_uevent_env(&audio->device->kobj, KOBJ_CHANGE,
1293 uac_event);
1294 dev_dbg(dev, "%s: sent uac uevent %s %s %s\n", __func__,
1295 uac_event[0], uac_event[1], uac_event[2]);
1296 }
1297 }
1298
ppm_calculate_work(struct work_struct * data)1299 static void ppm_calculate_work(struct work_struct *data)
1300 {
1301 struct g_audio *g_audio = container_of(data, struct g_audio,
1302 ppm_work.work);
1303 struct usb_gadget *gadget = g_audio->gadget;
1304 uint32_t frame_number, fn_msec, clk_msec;
1305 struct frame_number_data *fn = g_audio->fn;
1306 uint64_t time_now, time_msec_tmp;
1307 int32_t ppm;
1308 static int32_t ppms[CLK_PPM_GROUP_SIZE];
1309 static int32_t ppm_sum;
1310 int32_t cnt = fn->second % CLK_PPM_GROUP_SIZE;
1311
1312 time_now = ktime_get_raw();
1313 frame_number = gadget->ops->get_frame(gadget);
1314
1315 if (g_audio->fn->time_last &&
1316 time_now - g_audio->fn->time_last > 1500000000ULL)
1317 dev_warn(g_audio->device, "PPM work scheduled too slow!\n");
1318
1319 g_audio->fn->time_last = time_now;
1320
1321 /*
1322 * If usb is disconnected, the controller will not receive the
1323 * SoF signal and frame number will be invalid. Because we can't
1324 * get accurate time of disconnect and whether the gadget will be
1325 * plugged into the same host next time or not. We must clear all
1326 * statistics.
1327 */
1328 if (gadget->state != USB_STATE_CONFIGURED) {
1329 memset(g_audio->fn, 0, sizeof(*g_audio->fn));
1330 dev_dbg(g_audio->device, "Disconnect. frame number is cleared\n");
1331 goto out;
1332 }
1333
1334 /* Fist statistic to record begin frame number and system time */
1335 if (!g_audio->fn->second++) {
1336 g_audio->fn->time_begin = g_audio->fn->time_last;
1337 g_audio->fn->fn_begin = frame_number;
1338 g_audio->fn->fn_last = frame_number;
1339 goto out;
1340 }
1341
1342 /*
1343 * For DWC3 Controller, only 13 bits is used to store frame(micro)
1344 * number. In other words, the frame number will overflow at most
1345 * 2.047 seconds. We add another registor fn_overflow the record
1346 * total frame number.
1347 */
1348 if (frame_number <= g_audio->fn->fn_last)
1349 g_audio->fn->fn_overflow++;
1350 g_audio->fn->fn_last = frame_number;
1351
1352 if (!g_audio->fn->fn_overflow)
1353 goto out;
1354
1355 /* The lower 3 bits represent micro number frame, we don't need it */
1356 fn_msec = (((fn->fn_overflow - 1) << 14) +
1357 (BIT(14) + fn->fn_last - fn->fn_begin) + BIT(2)) >> 3;
1358 time_msec_tmp = fn->time_last - fn->time_begin + 500000ULL;
1359 do_div(time_msec_tmp, 1000000U);
1360 clk_msec = (uint32_t)time_msec_tmp;
1361
1362 /*
1363 * According to the definition of ppm:
1364 * host_clk = (1 + ppm / 1000000) * gadget_clk
1365 * we can get:
1366 * ppm = (host_clk - gadget_clk) * 1000000 / gadget_clk
1367 */
1368 ppm = (fn_msec > clk_msec) ?
1369 (fn_msec - clk_msec) * 1000000L / clk_msec :
1370 -((clk_msec - fn_msec) * 1000000L / clk_msec);
1371
1372 ppm_sum = ppm_sum - ppms[cnt] + ppm;
1373 ppms[cnt] = ppm;
1374
1375 dev_dbg(g_audio->device,
1376 "frame %u msec %u ppm_calc %d ppm_avage(%d) %d\n",
1377 fn_msec, clk_msec, ppm, CLK_PPM_GROUP_SIZE,
1378 ppm_sum / CLK_PPM_GROUP_SIZE);
1379
1380 /*
1381 * We calculate the average of ppm over a period of time. If the
1382 * latest frame number is too far from the average, no event will
1383 * be sent.
1384 */
1385 if (abs(ppm_sum / CLK_PPM_GROUP_SIZE - ppm) < 3) {
1386 ppm = ppm_sum > 0 ?
1387 (ppm_sum + CLK_PPM_GROUP_SIZE / 2) / CLK_PPM_GROUP_SIZE :
1388 (ppm_sum - CLK_PPM_GROUP_SIZE / 2) / CLK_PPM_GROUP_SIZE;
1389 if (ppm != g_audio->params.ppm) {
1390 g_audio->params.ppm = ppm;
1391 g_audio->usb_state[SET_AUDIO_CLK] = true;
1392 schedule_work(&g_audio->work);
1393 }
1394 }
1395
1396 out:
1397 schedule_delayed_work(&g_audio->ppm_work, 1 * HZ);
1398 }
1399
g_audio_setup(struct g_audio * g_audio,const char * pcm_name,const char * card_name)1400 int g_audio_setup(struct g_audio *g_audio, const char *pcm_name,
1401 const char *card_name)
1402 {
1403 struct snd_uac_chip *uac;
1404 struct snd_card *card;
1405 struct snd_pcm *pcm;
1406 struct snd_kcontrol *kctl;
1407 struct uac_params *params;
1408 int p_chmask, c_chmask;
1409 int i, err;
1410
1411 if (!g_audio)
1412 return -EINVAL;
1413
1414 uac = kzalloc(sizeof(*uac), GFP_KERNEL);
1415 if (!uac)
1416 return -ENOMEM;
1417 g_audio->uac = uac;
1418 uac->audio_dev = g_audio;
1419
1420 params = &g_audio->params;
1421 p_chmask = params->p_chmask;
1422 c_chmask = params->c_chmask;
1423
1424 g_audio->fn = kzalloc(sizeof(*g_audio->fn), GFP_KERNEL);
1425 if (!g_audio->fn) {
1426 err = -ENOMEM;
1427 goto fail;
1428 }
1429
1430 if (c_chmask) {
1431 struct uac_rtd_params *prm = &uac->c_prm;
1432
1433 spin_lock_init(&prm->lock);
1434 uac->c_prm.uac = uac;
1435 prm->max_psize = g_audio->out_ep_maxpsize;
1436 prm->srate = params->c_srates[0];
1437
1438 prm->reqs = kcalloc(params->req_number,
1439 sizeof(struct usb_request *),
1440 GFP_KERNEL);
1441 if (!prm->reqs) {
1442 err = -ENOMEM;
1443 goto fail;
1444 }
1445
1446 prm->rbuf = kcalloc(params->req_number, prm->max_psize,
1447 GFP_KERNEL);
1448 if (!prm->rbuf) {
1449 prm->max_psize = 0;
1450 err = -ENOMEM;
1451 goto fail;
1452 }
1453 }
1454
1455 if (p_chmask) {
1456 struct uac_rtd_params *prm = &uac->p_prm;
1457
1458 spin_lock_init(&prm->lock);
1459 uac->p_prm.uac = uac;
1460 prm->max_psize = g_audio->in_ep_maxpsize;
1461 prm->srate = params->p_srates[0];
1462
1463 prm->reqs = kcalloc(params->req_number,
1464 sizeof(struct usb_request *),
1465 GFP_KERNEL);
1466 if (!prm->reqs) {
1467 err = -ENOMEM;
1468 goto fail;
1469 }
1470
1471 prm->rbuf = kcalloc(params->req_number, prm->max_psize,
1472 GFP_KERNEL);
1473 if (!prm->rbuf) {
1474 prm->max_psize = 0;
1475 err = -ENOMEM;
1476 goto fail;
1477 }
1478 }
1479
1480 /* Choose any slot, with no id */
1481 err = snd_card_new(&g_audio->gadget->dev,
1482 -1, NULL, THIS_MODULE, 0, &card);
1483 if (err < 0)
1484 goto fail;
1485
1486 uac->card = card;
1487
1488 /*
1489 * Create first PCM device
1490 * Create a substream only for non-zero channel streams
1491 */
1492 err = snd_pcm_new(uac->card, pcm_name, 0,
1493 p_chmask ? 1 : 0, c_chmask ? 1 : 0, &pcm);
1494 if (err < 0)
1495 goto snd_fail;
1496
1497 strscpy(pcm->name, pcm_name, sizeof(pcm->name));
1498 pcm->private_data = uac;
1499 uac->pcm = pcm;
1500
1501 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &uac_pcm_ops);
1502 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &uac_pcm_ops);
1503
1504 /*
1505 * Create mixer and controls
1506 * Create only if it's required on USB side
1507 */
1508 if ((c_chmask && g_audio->in_ep_fback)
1509 || (p_chmask && params->p_fu.id)
1510 || (c_chmask && params->c_fu.id))
1511 strscpy(card->mixername, card_name, sizeof(card->driver));
1512
1513 if (c_chmask && g_audio->in_ep_fback) {
1514 kctl = snd_ctl_new1(&u_audio_controls[UAC_FBACK_CTRL],
1515 &uac->c_prm);
1516 if (!kctl) {
1517 err = -ENOMEM;
1518 goto snd_fail;
1519 }
1520
1521 kctl->id.device = pcm->device;
1522 kctl->id.subdevice = 0;
1523
1524 err = snd_ctl_add(card, kctl);
1525 if (err < 0)
1526 goto snd_fail;
1527 }
1528
1529 if (p_chmask) {
1530 kctl = snd_ctl_new1(&u_audio_controls[UAC_P_PITCH_CTRL],
1531 &uac->p_prm);
1532 if (!kctl) {
1533 err = -ENOMEM;
1534 goto snd_fail;
1535 }
1536
1537 kctl->id.device = pcm->device;
1538 kctl->id.subdevice = 0;
1539
1540 err = snd_ctl_add(card, kctl);
1541 if (err < 0)
1542 goto snd_fail;
1543 }
1544
1545 for (i = 0; i <= SNDRV_PCM_STREAM_LAST; i++) {
1546 struct uac_rtd_params *prm;
1547 struct uac_fu_params *fu;
1548 char ctrl_name[24];
1549 char *direction;
1550
1551 if (!pcm->streams[i].substream_count)
1552 continue;
1553
1554 if (i == SNDRV_PCM_STREAM_PLAYBACK) {
1555 prm = &uac->p_prm;
1556 fu = ¶ms->p_fu;
1557 direction = "Playback";
1558 } else {
1559 prm = &uac->c_prm;
1560 fu = ¶ms->c_fu;
1561 direction = "Capture";
1562 }
1563
1564 prm->fu_id = fu->id;
1565
1566 if (fu->mute_present) {
1567 snprintf(ctrl_name, sizeof(ctrl_name),
1568 "PCM %s Switch", direction);
1569
1570 u_audio_controls[UAC_MUTE_CTRL].name = ctrl_name;
1571
1572 kctl = snd_ctl_new1(&u_audio_controls[UAC_MUTE_CTRL],
1573 prm);
1574 if (!kctl) {
1575 err = -ENOMEM;
1576 goto snd_fail;
1577 }
1578
1579 kctl->id.device = pcm->device;
1580 kctl->id.subdevice = 0;
1581
1582 err = snd_ctl_add(card, kctl);
1583 if (err < 0)
1584 goto snd_fail;
1585 prm->snd_kctl_mute = kctl;
1586 prm->mute = 0;
1587 }
1588
1589 if (fu->volume_present) {
1590 snprintf(ctrl_name, sizeof(ctrl_name),
1591 "PCM %s Volume", direction);
1592
1593 u_audio_controls[UAC_VOLUME_CTRL].name = ctrl_name;
1594
1595 kctl = snd_ctl_new1(&u_audio_controls[UAC_VOLUME_CTRL],
1596 prm);
1597 if (!kctl) {
1598 err = -ENOMEM;
1599 goto snd_fail;
1600 }
1601
1602 kctl->id.device = pcm->device;
1603 kctl->id.subdevice = 0;
1604
1605
1606 kctl->tlv.c = u_audio_volume_tlv;
1607 kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ |
1608 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
1609
1610 err = snd_ctl_add(card, kctl);
1611 if (err < 0)
1612 goto snd_fail;
1613 prm->snd_kctl_volume = kctl;
1614 prm->volume = fu->volume_max;
1615 prm->volume_max = fu->volume_max;
1616 prm->volume_min = fu->volume_min;
1617 prm->volume_res = fu->volume_res;
1618 }
1619
1620 /* Add rate control */
1621 snprintf(ctrl_name, sizeof(ctrl_name),
1622 "%s Rate", direction);
1623 u_audio_controls[UAC_RATE_CTRL].name = ctrl_name;
1624
1625 kctl = snd_ctl_new1(&u_audio_controls[UAC_RATE_CTRL], prm);
1626 if (!kctl) {
1627 err = -ENOMEM;
1628 goto snd_fail;
1629 }
1630
1631 kctl->id.device = pcm->device;
1632 kctl->id.subdevice = 0;
1633
1634 err = snd_ctl_add(card, kctl);
1635 if (err < 0)
1636 goto snd_fail;
1637 prm->snd_kctl_rate = kctl;
1638 }
1639
1640 strscpy(card->driver, card_name, sizeof(card->driver));
1641 strscpy(card->shortname, card_name, sizeof(card->shortname));
1642 sprintf(card->longname, "%s %i", card_name, card->dev->id);
1643
1644 snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
1645 NULL, 0, BUFF_SIZE_MAX);
1646
1647 err = snd_card_register(card);
1648 if (err < 0)
1649 goto snd_fail;
1650
1651 g_audio->device = device_create(audio_class, NULL, MKDEV(0, 0), NULL,
1652 "%s", g_audio->uac->card->longname);
1653 if (IS_ERR(g_audio->device)) {
1654 err = PTR_ERR(g_audio->device);
1655 goto snd_fail;
1656 }
1657
1658 INIT_WORK(&g_audio->work, g_audio_work);
1659 INIT_DELAYED_WORK(&g_audio->ppm_work, ppm_calculate_work);
1660 ppm_calculate_work(&g_audio->ppm_work.work);
1661
1662 if (!err)
1663 return 0;
1664
1665 snd_fail:
1666 snd_card_free(card);
1667 fail:
1668 kfree(uac->p_prm.reqs);
1669 kfree(uac->c_prm.reqs);
1670 kfree(uac->p_prm.rbuf);
1671 kfree(uac->c_prm.rbuf);
1672 kfree(uac);
1673 kfree(g_audio->fn);
1674
1675 return err;
1676 }
1677 EXPORT_SYMBOL_GPL(g_audio_setup);
1678
g_audio_cleanup(struct g_audio * g_audio)1679 void g_audio_cleanup(struct g_audio *g_audio)
1680 {
1681 struct snd_uac_chip *uac;
1682 struct snd_card *card;
1683
1684 if (!g_audio || !g_audio->uac)
1685 return;
1686
1687 cancel_work_sync(&g_audio->work);
1688 cancel_delayed_work_sync(&g_audio->ppm_work);
1689 device_destroy(g_audio->device->class, g_audio->device->devt);
1690 g_audio->device = NULL;
1691
1692 uac = g_audio->uac;
1693 card = uac->card;
1694 if (card)
1695 snd_card_free(card);
1696
1697 kfree(uac->p_prm.reqs);
1698 kfree(uac->c_prm.reqs);
1699 kfree(uac->p_prm.rbuf);
1700 kfree(uac->c_prm.rbuf);
1701 kfree(uac);
1702 kfree(g_audio->fn);
1703 }
1704 EXPORT_SYMBOL_GPL(g_audio_cleanup);
1705
u_audio_init(void)1706 static int __init u_audio_init(void)
1707 {
1708 int err = 0;
1709
1710 audio_class = class_create(THIS_MODULE, "u_audio");
1711 if (IS_ERR(audio_class)) {
1712 err = PTR_ERR(audio_class);
1713 audio_class = NULL;
1714 }
1715
1716 return err;
1717 }
1718 module_init(u_audio_init);
1719
u_audio_exit(void)1720 static void __exit u_audio_exit(void)
1721 {
1722 if (audio_class)
1723 class_destroy(audio_class);
1724 }
1725 module_exit(u_audio_exit);
1726
1727 MODULE_LICENSE("GPL");
1728 MODULE_DESCRIPTION("USB gadget \"ALSA sound card\" utilities");
1729 MODULE_AUTHOR("Ruslan Bilovol");
1730