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 /* Runtime data params for one stream */ 39 struct uac_rtd_params { 40 struct snd_uac_chip *uac; /* parent chip */ 41 bool ep_enabled; /* if the ep is enabled */ 42 43 struct snd_pcm_substream *ss; 44 45 /* Ring buffer */ 46 ssize_t hw_ptr; 47 48 void *rbuf; 49 50 unsigned int pitch; /* Stream pitch ratio to 1000000 */ 51 unsigned int max_psize; /* MaxPacketSize of endpoint */ 52 53 struct usb_request **reqs; 54 55 struct usb_request *req_fback; /* Feedback endpoint request */ 56 bool fb_ep_enabled; /* if the ep is enabled */ 57 58 /* Volume/Mute controls and their state */ 59 int fu_id; /* Feature Unit ID */ 60 struct snd_kcontrol *snd_kctl_volume; 61 struct snd_kcontrol *snd_kctl_mute; 62 s16 volume_min, volume_max, volume_res; 63 s16 volume; 64 int mute; 65 66 struct snd_kcontrol *snd_kctl_rate; /* read-only current rate */ 67 int srate; /* selected samplerate */ 68 int active; /* playback/capture running */ 69 70 spinlock_t lock; /* lock for control transfers */ 71 72 }; 73 74 struct snd_uac_chip { 75 struct g_audio *audio_dev; 76 77 struct uac_rtd_params p_prm; 78 struct uac_rtd_params c_prm; 79 80 struct snd_card *card; 81 struct snd_pcm *pcm; 82 83 /* pre-calculated values for playback iso completion */ 84 unsigned long long p_residue_mil; 85 unsigned int p_interval; 86 unsigned int p_framesize; 87 }; 88 89 static const struct snd_pcm_hardware uac_pcm_hardware = { 90 .info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER 91 | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID 92 | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME, 93 .rates = SNDRV_PCM_RATE_CONTINUOUS, 94 .periods_max = BUFF_SIZE_MAX / PRD_SIZE_MAX, 95 .buffer_bytes_max = BUFF_SIZE_MAX, 96 .period_bytes_max = PRD_SIZE_MAX, 97 .periods_min = MIN_PERIODS, 98 }; 99 100 static void u_audio_set_fback_frequency(enum usb_device_speed speed, 101 struct usb_ep *out_ep, 102 unsigned long long freq, 103 unsigned int pitch, 104 void *buf) 105 { 106 u32 ff = 0; 107 const struct usb_endpoint_descriptor *ep_desc; 108 109 /* 110 * Because the pitch base is 1000000, the final divider here 111 * will be 1000 * 1000000 = 1953125 << 9 112 * 113 * Instead of dealing with big numbers lets fold this 9 left shift 114 */ 115 116 if (speed == USB_SPEED_FULL) { 117 /* 118 * Full-speed feedback endpoints report frequency 119 * in samples/frame 120 * Format is encoded in Q10.10 left-justified in the 24 bits, 121 * so that it has a Q10.14 format. 122 * 123 * ff = (freq << 14) / 1000 124 */ 125 freq <<= 5; 126 } else { 127 /* 128 * High-speed feedback endpoints report frequency 129 * in samples/microframe. 130 * Format is encoded in Q12.13 fitted into four bytes so that 131 * the binary point is located between the second and the third 132 * byte fromat (that is Q16.16) 133 * 134 * ff = (freq << 16) / 8000 135 * 136 * Win10 and OSX UAC2 drivers require number of samples per packet 137 * in order to honor the feedback value. 138 * Linux snd-usb-audio detects the applied bit-shift automatically. 139 */ 140 ep_desc = out_ep->desc; 141 freq <<= 4 + (ep_desc->bInterval - 1); 142 } 143 144 ff = DIV_ROUND_CLOSEST_ULL((freq * pitch), 1953125); 145 146 *(__le32 *)buf = cpu_to_le32(ff); 147 } 148 149 static void u_audio_iso_complete(struct usb_ep *ep, struct usb_request *req) 150 { 151 unsigned int pending; 152 unsigned int hw_ptr; 153 int status = req->status; 154 struct snd_pcm_substream *substream; 155 struct snd_pcm_runtime *runtime; 156 struct uac_rtd_params *prm = req->context; 157 struct snd_uac_chip *uac = prm->uac; 158 unsigned int frames, p_pktsize; 159 unsigned long long pitched_rate_mil, p_pktsize_residue_mil, 160 residue_frames_mil, div_result; 161 162 /* i/f shutting down */ 163 if (!prm->ep_enabled) { 164 usb_ep_free_request(ep, req); 165 return; 166 } 167 168 if (req->status == -ESHUTDOWN) 169 return; 170 171 /* 172 * We can't really do much about bad xfers. 173 * Afterall, the ISOCH xfers could fail legitimately. 174 */ 175 if (status) 176 pr_debug("%s: iso_complete status(%d) %d/%d\n", 177 __func__, status, req->actual, req->length); 178 179 substream = prm->ss; 180 181 /* Do nothing if ALSA isn't active */ 182 if (!substream) 183 goto exit; 184 185 snd_pcm_stream_lock(substream); 186 187 runtime = substream->runtime; 188 if (!runtime || !snd_pcm_running(substream)) { 189 snd_pcm_stream_unlock(substream); 190 goto exit; 191 } 192 193 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 194 /* 195 * For each IN packet, take the quotient of the current data 196 * rate and the endpoint's interval as the base packet size. 197 * If there is a residue from this division, add it to the 198 * residue accumulator. 199 */ 200 unsigned long long p_interval_mil = uac->p_interval * 1000000ULL; 201 202 pitched_rate_mil = (unsigned long long) prm->srate * prm->pitch; 203 div_result = pitched_rate_mil; 204 do_div(div_result, uac->p_interval); 205 do_div(div_result, 1000000); 206 frames = (unsigned int) div_result; 207 208 pr_debug("p_srate %d, pitch %d, interval_mil %llu, frames %d\n", 209 prm->srate, prm->pitch, p_interval_mil, frames); 210 211 p_pktsize = min_t(unsigned int, 212 uac->p_framesize * frames, 213 ep->maxpacket); 214 215 if (p_pktsize < ep->maxpacket) { 216 residue_frames_mil = pitched_rate_mil - frames * p_interval_mil; 217 p_pktsize_residue_mil = uac->p_framesize * residue_frames_mil; 218 } else 219 p_pktsize_residue_mil = 0; 220 221 req->length = p_pktsize; 222 uac->p_residue_mil += p_pktsize_residue_mil; 223 224 /* 225 * Whenever there are more bytes in the accumulator p_residue_mil than we 226 * need to add one more sample frame, increase this packet's 227 * size and decrease the accumulator. 228 */ 229 div_result = uac->p_residue_mil; 230 do_div(div_result, uac->p_interval); 231 do_div(div_result, 1000000); 232 if ((unsigned int) div_result >= uac->p_framesize) { 233 req->length += uac->p_framesize; 234 uac->p_residue_mil -= uac->p_framesize * p_interval_mil; 235 pr_debug("increased req length to %d\n", req->length); 236 } 237 pr_debug("remains uac->p_residue_mil %llu\n", uac->p_residue_mil); 238 239 req->actual = req->length; 240 } 241 242 hw_ptr = prm->hw_ptr; 243 244 /* Pack USB load in ALSA ring buffer */ 245 pending = runtime->dma_bytes - hw_ptr; 246 247 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 248 if (unlikely(pending < req->actual)) { 249 memcpy(req->buf, runtime->dma_area + hw_ptr, pending); 250 memcpy(req->buf + pending, runtime->dma_area, 251 req->actual - pending); 252 } else { 253 memcpy(req->buf, runtime->dma_area + hw_ptr, 254 req->actual); 255 } 256 } else { 257 if (unlikely(pending < req->actual)) { 258 memcpy(runtime->dma_area + hw_ptr, req->buf, pending); 259 memcpy(runtime->dma_area, req->buf + pending, 260 req->actual - pending); 261 } else { 262 memcpy(runtime->dma_area + hw_ptr, req->buf, 263 req->actual); 264 } 265 } 266 267 /* update hw_ptr after data is copied to memory */ 268 prm->hw_ptr = (hw_ptr + req->actual) % runtime->dma_bytes; 269 hw_ptr = prm->hw_ptr; 270 snd_pcm_stream_unlock(substream); 271 272 if ((hw_ptr % snd_pcm_lib_period_bytes(substream)) < req->actual) 273 snd_pcm_period_elapsed(substream); 274 275 exit: 276 if (usb_ep_queue(ep, req, GFP_ATOMIC)) 277 dev_err(uac->card->dev, "%d Error!\n", __LINE__); 278 } 279 280 static void u_audio_iso_fback_complete(struct usb_ep *ep, 281 struct usb_request *req) 282 { 283 struct uac_rtd_params *prm = req->context; 284 struct snd_uac_chip *uac = prm->uac; 285 struct g_audio *audio_dev = uac->audio_dev; 286 int status = req->status; 287 288 /* i/f shutting down */ 289 if (!prm->fb_ep_enabled) { 290 kfree(req->buf); 291 usb_ep_free_request(ep, req); 292 return; 293 } 294 295 if (req->status == -ESHUTDOWN) 296 return; 297 298 /* 299 * We can't really do much about bad xfers. 300 * Afterall, the ISOCH xfers could fail legitimately. 301 */ 302 if (status) 303 pr_debug("%s: iso_complete status(%d) %d/%d\n", 304 __func__, status, req->actual, req->length); 305 306 u_audio_set_fback_frequency(audio_dev->gadget->speed, audio_dev->out_ep, 307 prm->srate, prm->pitch, 308 req->buf); 309 310 if (usb_ep_queue(ep, req, GFP_ATOMIC)) 311 dev_err(uac->card->dev, "%d Error!\n", __LINE__); 312 } 313 314 static int uac_pcm_trigger(struct snd_pcm_substream *substream, int cmd) 315 { 316 struct snd_uac_chip *uac = snd_pcm_substream_chip(substream); 317 struct uac_rtd_params *prm; 318 struct g_audio *audio_dev; 319 struct uac_params *params; 320 int err = 0; 321 322 audio_dev = uac->audio_dev; 323 params = &audio_dev->params; 324 325 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 326 prm = &uac->p_prm; 327 else 328 prm = &uac->c_prm; 329 330 /* Reset */ 331 prm->hw_ptr = 0; 332 333 switch (cmd) { 334 case SNDRV_PCM_TRIGGER_START: 335 case SNDRV_PCM_TRIGGER_RESUME: 336 prm->ss = substream; 337 break; 338 case SNDRV_PCM_TRIGGER_STOP: 339 case SNDRV_PCM_TRIGGER_SUSPEND: 340 prm->ss = NULL; 341 break; 342 default: 343 err = -EINVAL; 344 } 345 346 /* Clear buffer after Play stops */ 347 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && !prm->ss) 348 memset(prm->rbuf, 0, prm->max_psize * params->req_number); 349 350 return err; 351 } 352 353 static snd_pcm_uframes_t uac_pcm_pointer(struct snd_pcm_substream *substream) 354 { 355 struct snd_uac_chip *uac = snd_pcm_substream_chip(substream); 356 struct uac_rtd_params *prm; 357 358 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 359 prm = &uac->p_prm; 360 else 361 prm = &uac->c_prm; 362 363 return bytes_to_frames(substream->runtime, prm->hw_ptr); 364 } 365 366 static u64 uac_ssize_to_fmt(int ssize) 367 { 368 u64 ret; 369 370 switch (ssize) { 371 case 3: 372 ret = SNDRV_PCM_FMTBIT_S24_3LE; 373 break; 374 case 4: 375 ret = SNDRV_PCM_FMTBIT_S32_LE; 376 break; 377 default: 378 ret = SNDRV_PCM_FMTBIT_S16_LE; 379 break; 380 } 381 382 return ret; 383 } 384 385 static int uac_pcm_open(struct snd_pcm_substream *substream) 386 { 387 struct snd_uac_chip *uac = snd_pcm_substream_chip(substream); 388 struct snd_pcm_runtime *runtime = substream->runtime; 389 struct g_audio *audio_dev; 390 struct uac_params *params; 391 struct uac_rtd_params *prm; 392 int p_ssize, c_ssize; 393 int p_chmask, c_chmask; 394 395 audio_dev = uac->audio_dev; 396 params = &audio_dev->params; 397 p_ssize = params->p_ssize; 398 c_ssize = params->c_ssize; 399 p_chmask = params->p_chmask; 400 c_chmask = params->c_chmask; 401 uac->p_residue_mil = 0; 402 403 runtime->hw = uac_pcm_hardware; 404 405 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 406 runtime->hw.formats = uac_ssize_to_fmt(p_ssize); 407 runtime->hw.channels_min = num_channels(p_chmask); 408 prm = &uac->p_prm; 409 } else { 410 runtime->hw.formats = uac_ssize_to_fmt(c_ssize); 411 runtime->hw.channels_min = num_channels(c_chmask); 412 prm = &uac->c_prm; 413 } 414 415 runtime->hw.period_bytes_min = 2 * prm->max_psize 416 / runtime->hw.periods_min; 417 runtime->hw.rate_min = prm->srate; 418 runtime->hw.rate_max = runtime->hw.rate_min; 419 runtime->hw.channels_max = runtime->hw.channels_min; 420 421 snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS); 422 423 return 0; 424 } 425 426 /* ALSA cries without these function pointers */ 427 static int uac_pcm_null(struct snd_pcm_substream *substream) 428 { 429 return 0; 430 } 431 432 static const struct snd_pcm_ops uac_pcm_ops = { 433 .open = uac_pcm_open, 434 .close = uac_pcm_null, 435 .trigger = uac_pcm_trigger, 436 .pointer = uac_pcm_pointer, 437 .prepare = uac_pcm_null, 438 }; 439 440 static inline void free_ep(struct uac_rtd_params *prm, struct usb_ep *ep) 441 { 442 struct snd_uac_chip *uac = prm->uac; 443 struct g_audio *audio_dev; 444 struct uac_params *params; 445 int i; 446 447 if (!prm->ep_enabled) 448 return; 449 450 audio_dev = uac->audio_dev; 451 params = &audio_dev->params; 452 453 for (i = 0; i < params->req_number; i++) { 454 if (prm->reqs[i]) { 455 if (usb_ep_dequeue(ep, prm->reqs[i])) 456 usb_ep_free_request(ep, prm->reqs[i]); 457 /* 458 * If usb_ep_dequeue() cannot successfully dequeue the 459 * request, the request will be freed by the completion 460 * callback. 461 */ 462 463 prm->reqs[i] = NULL; 464 } 465 } 466 467 prm->ep_enabled = false; 468 469 if (usb_ep_disable(ep)) 470 dev_err(uac->card->dev, "%s:%d Error!\n", __func__, __LINE__); 471 } 472 473 static inline void free_ep_fback(struct uac_rtd_params *prm, struct usb_ep *ep) 474 { 475 struct snd_uac_chip *uac = prm->uac; 476 477 if (!prm->fb_ep_enabled) 478 return; 479 480 if (prm->req_fback) { 481 if (usb_ep_dequeue(ep, prm->req_fback)) { 482 kfree(prm->req_fback->buf); 483 usb_ep_free_request(ep, prm->req_fback); 484 } 485 prm->req_fback = NULL; 486 } 487 488 prm->fb_ep_enabled = false; 489 490 if (usb_ep_disable(ep)) 491 dev_err(uac->card->dev, "%s:%d Error!\n", __func__, __LINE__); 492 } 493 494 static void set_active(struct uac_rtd_params *prm, bool active) 495 { 496 // notifying through the Rate ctrl 497 struct snd_kcontrol *kctl = prm->snd_kctl_rate; 498 unsigned long flags; 499 500 spin_lock_irqsave(&prm->lock, flags); 501 if (prm->active != active) { 502 prm->active = active; 503 snd_ctl_notify(prm->uac->card, SNDRV_CTL_EVENT_MASK_VALUE, 504 &kctl->id); 505 } 506 spin_unlock_irqrestore(&prm->lock, flags); 507 } 508 509 int u_audio_set_capture_srate(struct g_audio *audio_dev, int srate) 510 { 511 struct uac_params *params = &audio_dev->params; 512 struct snd_uac_chip *uac = audio_dev->uac; 513 struct uac_rtd_params *prm; 514 int i; 515 unsigned long flags; 516 517 dev_dbg(&audio_dev->gadget->dev, "%s: srate %d\n", __func__, srate); 518 prm = &uac->c_prm; 519 for (i = 0; i < UAC_MAX_RATES; i++) { 520 if (params->c_srates[i] == srate) { 521 spin_lock_irqsave(&prm->lock, flags); 522 prm->srate = srate; 523 spin_unlock_irqrestore(&prm->lock, flags); 524 return 0; 525 } 526 if (params->c_srates[i] == 0) 527 break; 528 } 529 530 return -EINVAL; 531 } 532 EXPORT_SYMBOL_GPL(u_audio_set_capture_srate); 533 534 int u_audio_get_capture_srate(struct g_audio *audio_dev, u32 *val) 535 { 536 struct snd_uac_chip *uac = audio_dev->uac; 537 struct uac_rtd_params *prm; 538 unsigned long flags; 539 540 prm = &uac->c_prm; 541 spin_lock_irqsave(&prm->lock, flags); 542 *val = prm->srate; 543 spin_unlock_irqrestore(&prm->lock, flags); 544 return 0; 545 } 546 EXPORT_SYMBOL_GPL(u_audio_get_capture_srate); 547 548 int u_audio_set_playback_srate(struct g_audio *audio_dev, int srate) 549 { 550 struct uac_params *params = &audio_dev->params; 551 struct snd_uac_chip *uac = audio_dev->uac; 552 struct uac_rtd_params *prm; 553 int i; 554 unsigned long flags; 555 556 dev_dbg(&audio_dev->gadget->dev, "%s: srate %d\n", __func__, srate); 557 prm = &uac->p_prm; 558 for (i = 0; i < UAC_MAX_RATES; i++) { 559 if (params->p_srates[i] == srate) { 560 spin_lock_irqsave(&prm->lock, flags); 561 prm->srate = srate; 562 spin_unlock_irqrestore(&prm->lock, flags); 563 return 0; 564 } 565 if (params->p_srates[i] == 0) 566 break; 567 } 568 569 return -EINVAL; 570 } 571 EXPORT_SYMBOL_GPL(u_audio_set_playback_srate); 572 573 int u_audio_get_playback_srate(struct g_audio *audio_dev, u32 *val) 574 { 575 struct snd_uac_chip *uac = audio_dev->uac; 576 struct uac_rtd_params *prm; 577 unsigned long flags; 578 579 prm = &uac->p_prm; 580 spin_lock_irqsave(&prm->lock, flags); 581 *val = prm->srate; 582 spin_unlock_irqrestore(&prm->lock, flags); 583 return 0; 584 } 585 EXPORT_SYMBOL_GPL(u_audio_get_playback_srate); 586 587 int u_audio_start_capture(struct g_audio *audio_dev) 588 { 589 struct snd_uac_chip *uac = audio_dev->uac; 590 struct usb_gadget *gadget = audio_dev->gadget; 591 struct device *dev = &gadget->dev; 592 struct usb_request *req, *req_fback; 593 struct usb_ep *ep, *ep_fback; 594 struct uac_rtd_params *prm; 595 struct uac_params *params = &audio_dev->params; 596 int req_len, i; 597 598 prm = &uac->c_prm; 599 dev_dbg(dev, "start capture with rate %d\n", prm->srate); 600 ep = audio_dev->out_ep; 601 config_ep_by_speed(gadget, &audio_dev->func, ep); 602 req_len = ep->maxpacket; 603 604 prm->ep_enabled = true; 605 usb_ep_enable(ep); 606 607 for (i = 0; i < params->req_number; i++) { 608 if (!prm->reqs[i]) { 609 req = usb_ep_alloc_request(ep, GFP_ATOMIC); 610 if (req == NULL) 611 return -ENOMEM; 612 613 prm->reqs[i] = req; 614 615 req->zero = 0; 616 req->context = prm; 617 req->length = req_len; 618 req->complete = u_audio_iso_complete; 619 req->buf = prm->rbuf + i * ep->maxpacket; 620 } 621 622 if (usb_ep_queue(ep, prm->reqs[i], GFP_ATOMIC)) 623 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__); 624 } 625 626 set_active(&uac->c_prm, true); 627 628 ep_fback = audio_dev->in_ep_fback; 629 if (!ep_fback) 630 return 0; 631 632 /* Setup feedback endpoint */ 633 config_ep_by_speed(gadget, &audio_dev->func, ep_fback); 634 prm->fb_ep_enabled = true; 635 usb_ep_enable(ep_fback); 636 req_len = ep_fback->maxpacket; 637 638 req_fback = usb_ep_alloc_request(ep_fback, GFP_ATOMIC); 639 if (req_fback == NULL) 640 return -ENOMEM; 641 642 prm->req_fback = req_fback; 643 req_fback->zero = 0; 644 req_fback->context = prm; 645 req_fback->length = req_len; 646 req_fback->complete = u_audio_iso_fback_complete; 647 648 req_fback->buf = kzalloc(req_len, GFP_ATOMIC); 649 if (!req_fback->buf) 650 return -ENOMEM; 651 652 /* 653 * Configure the feedback endpoint's reported frequency. 654 * Always start with original frequency since its deviation can't 655 * be meauserd at start of playback 656 */ 657 prm->pitch = 1000000; 658 u_audio_set_fback_frequency(audio_dev->gadget->speed, ep, 659 prm->srate, prm->pitch, 660 req_fback->buf); 661 662 if (usb_ep_queue(ep_fback, req_fback, GFP_ATOMIC)) 663 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__); 664 665 return 0; 666 } 667 EXPORT_SYMBOL_GPL(u_audio_start_capture); 668 669 void u_audio_stop_capture(struct g_audio *audio_dev) 670 { 671 struct snd_uac_chip *uac = audio_dev->uac; 672 673 set_active(&uac->c_prm, false); 674 if (audio_dev->in_ep_fback) 675 free_ep_fback(&uac->c_prm, audio_dev->in_ep_fback); 676 free_ep(&uac->c_prm, audio_dev->out_ep); 677 } 678 EXPORT_SYMBOL_GPL(u_audio_stop_capture); 679 680 int u_audio_start_playback(struct g_audio *audio_dev) 681 { 682 struct snd_uac_chip *uac = audio_dev->uac; 683 struct usb_gadget *gadget = audio_dev->gadget; 684 struct device *dev = &gadget->dev; 685 struct usb_request *req; 686 struct usb_ep *ep; 687 struct uac_rtd_params *prm; 688 struct uac_params *params = &audio_dev->params; 689 unsigned int factor; 690 const struct usb_endpoint_descriptor *ep_desc; 691 int req_len, i; 692 unsigned int p_pktsize; 693 694 prm = &uac->p_prm; 695 dev_dbg(dev, "start playback with rate %d\n", prm->srate); 696 ep = audio_dev->in_ep; 697 config_ep_by_speed(gadget, &audio_dev->func, ep); 698 699 ep_desc = ep->desc; 700 /* 701 * Always start with original frequency 702 */ 703 prm->pitch = 1000000; 704 705 /* pre-calculate the playback endpoint's interval */ 706 if (gadget->speed == USB_SPEED_FULL) 707 factor = 1000; 708 else 709 factor = 8000; 710 711 /* pre-compute some values for iso_complete() */ 712 uac->p_framesize = params->p_ssize * 713 num_channels(params->p_chmask); 714 uac->p_interval = factor / (1 << (ep_desc->bInterval - 1)); 715 p_pktsize = min_t(unsigned int, 716 uac->p_framesize * 717 (prm->srate / uac->p_interval), 718 ep->maxpacket); 719 720 req_len = p_pktsize; 721 uac->p_residue_mil = 0; 722 723 prm->ep_enabled = true; 724 usb_ep_enable(ep); 725 726 for (i = 0; i < params->req_number; i++) { 727 if (!prm->reqs[i]) { 728 req = usb_ep_alloc_request(ep, GFP_ATOMIC); 729 if (req == NULL) 730 return -ENOMEM; 731 732 prm->reqs[i] = req; 733 734 req->zero = 0; 735 req->context = prm; 736 req->length = req_len; 737 req->complete = u_audio_iso_complete; 738 req->buf = prm->rbuf + i * ep->maxpacket; 739 } 740 741 if (usb_ep_queue(ep, prm->reqs[i], GFP_ATOMIC)) 742 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__); 743 } 744 745 set_active(&uac->p_prm, true); 746 747 return 0; 748 } 749 EXPORT_SYMBOL_GPL(u_audio_start_playback); 750 751 void u_audio_stop_playback(struct g_audio *audio_dev) 752 { 753 struct snd_uac_chip *uac = audio_dev->uac; 754 755 set_active(&uac->p_prm, false); 756 free_ep(&uac->p_prm, audio_dev->in_ep); 757 } 758 EXPORT_SYMBOL_GPL(u_audio_stop_playback); 759 760 void u_audio_suspend(struct g_audio *audio_dev) 761 { 762 struct snd_uac_chip *uac = audio_dev->uac; 763 764 set_active(&uac->p_prm, false); 765 set_active(&uac->c_prm, false); 766 } 767 EXPORT_SYMBOL_GPL(u_audio_suspend); 768 769 int u_audio_get_volume(struct g_audio *audio_dev, int playback, s16 *val) 770 { 771 struct snd_uac_chip *uac = audio_dev->uac; 772 struct uac_rtd_params *prm; 773 unsigned long flags; 774 775 if (playback) 776 prm = &uac->p_prm; 777 else 778 prm = &uac->c_prm; 779 780 spin_lock_irqsave(&prm->lock, flags); 781 *val = prm->volume; 782 spin_unlock_irqrestore(&prm->lock, flags); 783 784 return 0; 785 } 786 EXPORT_SYMBOL_GPL(u_audio_get_volume); 787 788 int u_audio_set_volume(struct g_audio *audio_dev, int playback, s16 val) 789 { 790 struct snd_uac_chip *uac = audio_dev->uac; 791 struct uac_rtd_params *prm; 792 unsigned long flags; 793 int change = 0; 794 795 if (playback) 796 prm = &uac->p_prm; 797 else 798 prm = &uac->c_prm; 799 800 spin_lock_irqsave(&prm->lock, flags); 801 val = clamp(val, prm->volume_min, prm->volume_max); 802 if (prm->volume != val) { 803 prm->volume = val; 804 change = 1; 805 } 806 spin_unlock_irqrestore(&prm->lock, flags); 807 808 if (change) 809 snd_ctl_notify(uac->card, SNDRV_CTL_EVENT_MASK_VALUE, 810 &prm->snd_kctl_volume->id); 811 812 return 0; 813 } 814 EXPORT_SYMBOL_GPL(u_audio_set_volume); 815 816 int u_audio_get_mute(struct g_audio *audio_dev, int playback, int *val) 817 { 818 struct snd_uac_chip *uac = audio_dev->uac; 819 struct uac_rtd_params *prm; 820 unsigned long flags; 821 822 if (playback) 823 prm = &uac->p_prm; 824 else 825 prm = &uac->c_prm; 826 827 spin_lock_irqsave(&prm->lock, flags); 828 *val = prm->mute; 829 spin_unlock_irqrestore(&prm->lock, flags); 830 831 return 0; 832 } 833 EXPORT_SYMBOL_GPL(u_audio_get_mute); 834 835 int u_audio_set_mute(struct g_audio *audio_dev, int playback, int val) 836 { 837 struct snd_uac_chip *uac = audio_dev->uac; 838 struct uac_rtd_params *prm; 839 unsigned long flags; 840 int change = 0; 841 int mute; 842 843 if (playback) 844 prm = &uac->p_prm; 845 else 846 prm = &uac->c_prm; 847 848 mute = val ? 1 : 0; 849 850 spin_lock_irqsave(&prm->lock, flags); 851 if (prm->mute != mute) { 852 prm->mute = mute; 853 change = 1; 854 } 855 spin_unlock_irqrestore(&prm->lock, flags); 856 857 if (change) 858 snd_ctl_notify(uac->card, SNDRV_CTL_EVENT_MASK_VALUE, 859 &prm->snd_kctl_mute->id); 860 861 return 0; 862 } 863 EXPORT_SYMBOL_GPL(u_audio_set_mute); 864 865 866 static int u_audio_pitch_info(struct snd_kcontrol *kcontrol, 867 struct snd_ctl_elem_info *uinfo) 868 { 869 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol); 870 struct snd_uac_chip *uac = prm->uac; 871 struct g_audio *audio_dev = uac->audio_dev; 872 struct uac_params *params = &audio_dev->params; 873 unsigned int pitch_min, pitch_max; 874 875 pitch_min = (1000 - FBACK_SLOW_MAX) * 1000; 876 pitch_max = (1000 + params->fb_max) * 1000; 877 878 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 879 uinfo->count = 1; 880 uinfo->value.integer.min = pitch_min; 881 uinfo->value.integer.max = pitch_max; 882 uinfo->value.integer.step = 1; 883 return 0; 884 } 885 886 static int u_audio_pitch_get(struct snd_kcontrol *kcontrol, 887 struct snd_ctl_elem_value *ucontrol) 888 { 889 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol); 890 891 ucontrol->value.integer.value[0] = prm->pitch; 892 893 return 0; 894 } 895 896 static int u_audio_pitch_put(struct snd_kcontrol *kcontrol, 897 struct snd_ctl_elem_value *ucontrol) 898 { 899 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol); 900 struct snd_uac_chip *uac = prm->uac; 901 struct g_audio *audio_dev = uac->audio_dev; 902 struct uac_params *params = &audio_dev->params; 903 unsigned int val; 904 unsigned int pitch_min, pitch_max; 905 int change = 0; 906 907 pitch_min = (1000 - FBACK_SLOW_MAX) * 1000; 908 pitch_max = (1000 + params->fb_max) * 1000; 909 910 val = ucontrol->value.integer.value[0]; 911 912 if (val < pitch_min) 913 val = pitch_min; 914 if (val > pitch_max) 915 val = pitch_max; 916 917 if (prm->pitch != val) { 918 prm->pitch = val; 919 change = 1; 920 } 921 922 return change; 923 } 924 925 static int u_audio_mute_info(struct snd_kcontrol *kcontrol, 926 struct snd_ctl_elem_info *uinfo) 927 { 928 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 929 uinfo->count = 1; 930 uinfo->value.integer.min = 0; 931 uinfo->value.integer.max = 1; 932 uinfo->value.integer.step = 1; 933 934 return 0; 935 } 936 937 static int u_audio_mute_get(struct snd_kcontrol *kcontrol, 938 struct snd_ctl_elem_value *ucontrol) 939 { 940 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol); 941 unsigned long flags; 942 943 spin_lock_irqsave(&prm->lock, flags); 944 ucontrol->value.integer.value[0] = !prm->mute; 945 spin_unlock_irqrestore(&prm->lock, flags); 946 947 return 0; 948 } 949 950 static int u_audio_mute_put(struct snd_kcontrol *kcontrol, 951 struct snd_ctl_elem_value *ucontrol) 952 { 953 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol); 954 struct snd_uac_chip *uac = prm->uac; 955 struct g_audio *audio_dev = uac->audio_dev; 956 unsigned int val; 957 unsigned long flags; 958 int change = 0; 959 960 val = !ucontrol->value.integer.value[0]; 961 962 spin_lock_irqsave(&prm->lock, flags); 963 if (val != prm->mute) { 964 prm->mute = val; 965 change = 1; 966 } 967 spin_unlock_irqrestore(&prm->lock, flags); 968 969 if (change && audio_dev->notify) 970 audio_dev->notify(audio_dev, prm->fu_id, UAC_FU_MUTE); 971 972 return change; 973 } 974 975 /* 976 * TLV callback for mixer volume controls 977 */ 978 static int u_audio_volume_tlv(struct snd_kcontrol *kcontrol, int op_flag, 979 unsigned int size, unsigned int __user *_tlv) 980 { 981 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol); 982 DECLARE_TLV_DB_MINMAX(scale, 0, 0); 983 984 if (size < sizeof(scale)) 985 return -ENOMEM; 986 987 /* UAC volume resolution is 1/256 dB, TLV is 1/100 dB */ 988 scale[2] = (prm->volume_min * 100) / 256; 989 scale[3] = (prm->volume_max * 100) / 256; 990 if (copy_to_user(_tlv, scale, sizeof(scale))) 991 return -EFAULT; 992 993 return 0; 994 } 995 996 static int u_audio_volume_info(struct snd_kcontrol *kcontrol, 997 struct snd_ctl_elem_info *uinfo) 998 { 999 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol); 1000 1001 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1002 uinfo->count = 1; 1003 uinfo->value.integer.min = 0; 1004 uinfo->value.integer.max = 1005 (prm->volume_max - prm->volume_min + prm->volume_res - 1) 1006 / prm->volume_res; 1007 uinfo->value.integer.step = 1; 1008 1009 return 0; 1010 } 1011 1012 static int u_audio_volume_get(struct snd_kcontrol *kcontrol, 1013 struct snd_ctl_elem_value *ucontrol) 1014 { 1015 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol); 1016 unsigned long flags; 1017 1018 spin_lock_irqsave(&prm->lock, flags); 1019 ucontrol->value.integer.value[0] = 1020 (prm->volume - prm->volume_min) / prm->volume_res; 1021 spin_unlock_irqrestore(&prm->lock, flags); 1022 1023 return 0; 1024 } 1025 1026 static int u_audio_volume_put(struct snd_kcontrol *kcontrol, 1027 struct snd_ctl_elem_value *ucontrol) 1028 { 1029 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol); 1030 struct snd_uac_chip *uac = prm->uac; 1031 struct g_audio *audio_dev = uac->audio_dev; 1032 unsigned int val; 1033 s16 volume; 1034 unsigned long flags; 1035 int change = 0; 1036 1037 val = ucontrol->value.integer.value[0]; 1038 1039 spin_lock_irqsave(&prm->lock, flags); 1040 volume = (val * prm->volume_res) + prm->volume_min; 1041 volume = clamp(volume, prm->volume_min, prm->volume_max); 1042 if (volume != prm->volume) { 1043 prm->volume = volume; 1044 change = 1; 1045 } 1046 spin_unlock_irqrestore(&prm->lock, flags); 1047 1048 if (change && audio_dev->notify) 1049 audio_dev->notify(audio_dev, prm->fu_id, UAC_FU_VOLUME); 1050 1051 return change; 1052 } 1053 1054 static int get_max_srate(const int *srates) 1055 { 1056 int i, max_srate = 0; 1057 1058 for (i = 0; i < UAC_MAX_RATES; i++) { 1059 if (srates[i] == 0) 1060 break; 1061 if (srates[i] > max_srate) 1062 max_srate = srates[i]; 1063 } 1064 return max_srate; 1065 } 1066 1067 static int get_min_srate(const int *srates) 1068 { 1069 int i, min_srate = INT_MAX; 1070 1071 for (i = 0; i < UAC_MAX_RATES; i++) { 1072 if (srates[i] == 0) 1073 break; 1074 if (srates[i] < min_srate) 1075 min_srate = srates[i]; 1076 } 1077 return min_srate; 1078 } 1079 1080 static int u_audio_rate_info(struct snd_kcontrol *kcontrol, 1081 struct snd_ctl_elem_info *uinfo) 1082 { 1083 const int *srates; 1084 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol); 1085 struct snd_uac_chip *uac = prm->uac; 1086 struct g_audio *audio_dev = uac->audio_dev; 1087 struct uac_params *params = &audio_dev->params; 1088 1089 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1090 uinfo->count = 1; 1091 1092 if (prm == &uac->c_prm) 1093 srates = params->c_srates; 1094 else 1095 srates = params->p_srates; 1096 uinfo->value.integer.min = get_min_srate(srates); 1097 uinfo->value.integer.max = get_max_srate(srates); 1098 return 0; 1099 } 1100 1101 static int u_audio_rate_get(struct snd_kcontrol *kcontrol, 1102 struct snd_ctl_elem_value *ucontrol) 1103 { 1104 struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol); 1105 unsigned long flags; 1106 1107 spin_lock_irqsave(&prm->lock, flags); 1108 if (prm->active) 1109 ucontrol->value.integer.value[0] = prm->srate; 1110 else 1111 /* not active: reporting zero rate */ 1112 ucontrol->value.integer.value[0] = 0; 1113 spin_unlock_irqrestore(&prm->lock, flags); 1114 return 0; 1115 } 1116 1117 static struct snd_kcontrol_new u_audio_controls[] = { 1118 [UAC_FBACK_CTRL] { 1119 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1120 .name = "Capture Pitch 1000000", 1121 .info = u_audio_pitch_info, 1122 .get = u_audio_pitch_get, 1123 .put = u_audio_pitch_put, 1124 }, 1125 [UAC_P_PITCH_CTRL] { 1126 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1127 .name = "Playback Pitch 1000000", 1128 .info = u_audio_pitch_info, 1129 .get = u_audio_pitch_get, 1130 .put = u_audio_pitch_put, 1131 }, 1132 [UAC_MUTE_CTRL] { 1133 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1134 .name = "", /* will be filled later */ 1135 .info = u_audio_mute_info, 1136 .get = u_audio_mute_get, 1137 .put = u_audio_mute_put, 1138 }, 1139 [UAC_VOLUME_CTRL] { 1140 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1141 .name = "", /* will be filled later */ 1142 .info = u_audio_volume_info, 1143 .get = u_audio_volume_get, 1144 .put = u_audio_volume_put, 1145 }, 1146 [UAC_RATE_CTRL] { 1147 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 1148 .name = "", /* will be filled later */ 1149 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 1150 .info = u_audio_rate_info, 1151 .get = u_audio_rate_get, 1152 }, 1153 }; 1154 1155 int g_audio_setup(struct g_audio *g_audio, const char *pcm_name, 1156 const char *card_name) 1157 { 1158 struct snd_uac_chip *uac; 1159 struct snd_card *card; 1160 struct snd_pcm *pcm; 1161 struct snd_kcontrol *kctl; 1162 struct uac_params *params; 1163 int p_chmask, c_chmask; 1164 int i, err; 1165 1166 if (!g_audio) 1167 return -EINVAL; 1168 1169 uac = kzalloc(sizeof(*uac), GFP_KERNEL); 1170 if (!uac) 1171 return -ENOMEM; 1172 g_audio->uac = uac; 1173 uac->audio_dev = g_audio; 1174 1175 params = &g_audio->params; 1176 p_chmask = params->p_chmask; 1177 c_chmask = params->c_chmask; 1178 1179 if (c_chmask) { 1180 struct uac_rtd_params *prm = &uac->c_prm; 1181 1182 spin_lock_init(&prm->lock); 1183 uac->c_prm.uac = uac; 1184 prm->max_psize = g_audio->out_ep_maxpsize; 1185 prm->srate = params->c_srates[0]; 1186 1187 prm->reqs = kcalloc(params->req_number, 1188 sizeof(struct usb_request *), 1189 GFP_KERNEL); 1190 if (!prm->reqs) { 1191 err = -ENOMEM; 1192 goto fail; 1193 } 1194 1195 prm->rbuf = kcalloc(params->req_number, prm->max_psize, 1196 GFP_KERNEL); 1197 if (!prm->rbuf) { 1198 prm->max_psize = 0; 1199 err = -ENOMEM; 1200 goto fail; 1201 } 1202 } 1203 1204 if (p_chmask) { 1205 struct uac_rtd_params *prm = &uac->p_prm; 1206 1207 spin_lock_init(&prm->lock); 1208 uac->p_prm.uac = uac; 1209 prm->max_psize = g_audio->in_ep_maxpsize; 1210 prm->srate = params->p_srates[0]; 1211 1212 prm->reqs = kcalloc(params->req_number, 1213 sizeof(struct usb_request *), 1214 GFP_KERNEL); 1215 if (!prm->reqs) { 1216 err = -ENOMEM; 1217 goto fail; 1218 } 1219 1220 prm->rbuf = kcalloc(params->req_number, prm->max_psize, 1221 GFP_KERNEL); 1222 if (!prm->rbuf) { 1223 prm->max_psize = 0; 1224 err = -ENOMEM; 1225 goto fail; 1226 } 1227 } 1228 1229 /* Choose any slot, with no id */ 1230 err = snd_card_new(&g_audio->gadget->dev, 1231 -1, NULL, THIS_MODULE, 0, &card); 1232 if (err < 0) 1233 goto fail; 1234 1235 uac->card = card; 1236 1237 /* 1238 * Create first PCM device 1239 * Create a substream only for non-zero channel streams 1240 */ 1241 err = snd_pcm_new(uac->card, pcm_name, 0, 1242 p_chmask ? 1 : 0, c_chmask ? 1 : 0, &pcm); 1243 if (err < 0) 1244 goto snd_fail; 1245 1246 strscpy(pcm->name, pcm_name, sizeof(pcm->name)); 1247 pcm->private_data = uac; 1248 uac->pcm = pcm; 1249 1250 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &uac_pcm_ops); 1251 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &uac_pcm_ops); 1252 1253 /* 1254 * Create mixer and controls 1255 * Create only if it's required on USB side 1256 */ 1257 if ((c_chmask && g_audio->in_ep_fback) 1258 || (p_chmask && params->p_fu.id) 1259 || (c_chmask && params->c_fu.id)) 1260 strscpy(card->mixername, card_name, sizeof(card->driver)); 1261 1262 if (c_chmask && g_audio->in_ep_fback) { 1263 kctl = snd_ctl_new1(&u_audio_controls[UAC_FBACK_CTRL], 1264 &uac->c_prm); 1265 if (!kctl) { 1266 err = -ENOMEM; 1267 goto snd_fail; 1268 } 1269 1270 kctl->id.device = pcm->device; 1271 kctl->id.subdevice = 0; 1272 1273 err = snd_ctl_add(card, kctl); 1274 if (err < 0) 1275 goto snd_fail; 1276 } 1277 1278 if (p_chmask) { 1279 kctl = snd_ctl_new1(&u_audio_controls[UAC_P_PITCH_CTRL], 1280 &uac->p_prm); 1281 if (!kctl) { 1282 err = -ENOMEM; 1283 goto snd_fail; 1284 } 1285 1286 kctl->id.device = pcm->device; 1287 kctl->id.subdevice = 0; 1288 1289 err = snd_ctl_add(card, kctl); 1290 if (err < 0) 1291 goto snd_fail; 1292 } 1293 1294 for (i = 0; i <= SNDRV_PCM_STREAM_LAST; i++) { 1295 struct uac_rtd_params *prm; 1296 struct uac_fu_params *fu; 1297 char ctrl_name[24]; 1298 char *direction; 1299 1300 if (!pcm->streams[i].substream_count) 1301 continue; 1302 1303 if (i == SNDRV_PCM_STREAM_PLAYBACK) { 1304 prm = &uac->p_prm; 1305 fu = ¶ms->p_fu; 1306 direction = "Playback"; 1307 } else { 1308 prm = &uac->c_prm; 1309 fu = ¶ms->c_fu; 1310 direction = "Capture"; 1311 } 1312 1313 prm->fu_id = fu->id; 1314 1315 if (fu->mute_present) { 1316 snprintf(ctrl_name, sizeof(ctrl_name), 1317 "PCM %s Switch", direction); 1318 1319 u_audio_controls[UAC_MUTE_CTRL].name = ctrl_name; 1320 1321 kctl = snd_ctl_new1(&u_audio_controls[UAC_MUTE_CTRL], 1322 prm); 1323 if (!kctl) { 1324 err = -ENOMEM; 1325 goto snd_fail; 1326 } 1327 1328 kctl->id.device = pcm->device; 1329 kctl->id.subdevice = 0; 1330 1331 err = snd_ctl_add(card, kctl); 1332 if (err < 0) 1333 goto snd_fail; 1334 prm->snd_kctl_mute = kctl; 1335 prm->mute = 0; 1336 } 1337 1338 if (fu->volume_present) { 1339 snprintf(ctrl_name, sizeof(ctrl_name), 1340 "PCM %s Volume", direction); 1341 1342 u_audio_controls[UAC_VOLUME_CTRL].name = ctrl_name; 1343 1344 kctl = snd_ctl_new1(&u_audio_controls[UAC_VOLUME_CTRL], 1345 prm); 1346 if (!kctl) { 1347 err = -ENOMEM; 1348 goto snd_fail; 1349 } 1350 1351 kctl->id.device = pcm->device; 1352 kctl->id.subdevice = 0; 1353 1354 1355 kctl->tlv.c = u_audio_volume_tlv; 1356 kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ | 1357 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK; 1358 1359 err = snd_ctl_add(card, kctl); 1360 if (err < 0) 1361 goto snd_fail; 1362 prm->snd_kctl_volume = kctl; 1363 prm->volume = fu->volume_max; 1364 prm->volume_max = fu->volume_max; 1365 prm->volume_min = fu->volume_min; 1366 prm->volume_res = fu->volume_res; 1367 } 1368 1369 /* Add rate control */ 1370 snprintf(ctrl_name, sizeof(ctrl_name), 1371 "%s Rate", direction); 1372 u_audio_controls[UAC_RATE_CTRL].name = ctrl_name; 1373 1374 kctl = snd_ctl_new1(&u_audio_controls[UAC_RATE_CTRL], prm); 1375 if (!kctl) { 1376 err = -ENOMEM; 1377 goto snd_fail; 1378 } 1379 1380 kctl->id.device = pcm->device; 1381 kctl->id.subdevice = 0; 1382 1383 err = snd_ctl_add(card, kctl); 1384 if (err < 0) 1385 goto snd_fail; 1386 prm->snd_kctl_rate = kctl; 1387 } 1388 1389 strscpy(card->driver, card_name, sizeof(card->driver)); 1390 strscpy(card->shortname, card_name, sizeof(card->shortname)); 1391 sprintf(card->longname, "%s %i", card_name, card->dev->id); 1392 1393 snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS, 1394 NULL, 0, BUFF_SIZE_MAX); 1395 1396 err = snd_card_register(card); 1397 1398 if (!err) 1399 return 0; 1400 1401 snd_fail: 1402 snd_card_free(card); 1403 fail: 1404 kfree(uac->p_prm.reqs); 1405 kfree(uac->c_prm.reqs); 1406 kfree(uac->p_prm.rbuf); 1407 kfree(uac->c_prm.rbuf); 1408 kfree(uac); 1409 1410 return err; 1411 } 1412 EXPORT_SYMBOL_GPL(g_audio_setup); 1413 1414 void g_audio_cleanup(struct g_audio *g_audio) 1415 { 1416 struct snd_uac_chip *uac; 1417 struct snd_card *card; 1418 1419 if (!g_audio || !g_audio->uac) 1420 return; 1421 1422 uac = g_audio->uac; 1423 card = uac->card; 1424 if (card) 1425 snd_card_free(card); 1426 1427 kfree(uac->p_prm.reqs); 1428 kfree(uac->c_prm.reqs); 1429 kfree(uac->p_prm.rbuf); 1430 kfree(uac->c_prm.rbuf); 1431 kfree(uac); 1432 } 1433 EXPORT_SYMBOL_GPL(g_audio_cleanup); 1434 1435 MODULE_LICENSE("GPL"); 1436 MODULE_DESCRIPTION("USB gadget \"ALSA sound card\" utilities"); 1437 MODULE_AUTHOR("Ruslan Bilovol"); 1438